typia 5.3.12-dev.20240121 → 5.3.12

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,141 +1,141 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../schemas/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 "../../schemas/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,
+          ),
+        ),
+      ],
+    );

package/src/programmers/helpers/RandomJoiner.ts

@@ -1,140 +1,140 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { Escaper } from "../../utils/Escaper";
-
-export namespace RandomJoiner {
-  export type Decoder = (meta: Metadata) => ts.Expression;
-
-  export const array =
-    (coalesce: (method: string) => ts.Expression) =>
-    (decoder: Decoder) =>
-    (explore: IExplore) =>
-    (length: ts.Expression | undefined) =>
-    (item: Metadata): ts.Expression => {
-      const generator: ts.Expression = ts.factory.createCallExpression(
-        coalesce("array"),
-        undefined,
-        [
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [],
-            undefined,
-            undefined,
-            decoder(item),
-          ),
-          ...(length ? [length] : []),
-        ],
-      );
-      if (explore.recursive === false) return generator;
-      return ts.factory.createConditionalExpression(
-        ts.factory.createGreaterThanEquals(
-          ExpressionFactory.number(5),
-          ts.factory.createIdentifier("_depth"),
-        ),
-        undefined,
-        generator,
-        undefined,
-        ts.factory.createArrayLiteralExpression([]),
-      );
-    };
-
-  export const tuple = (decoder: Decoder) => (elements: Metadata[]) =>
-    ts.factory.createArrayLiteralExpression(
-      elements.map((elem) => decoder(elem.rest ?? elem)),
-      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),
-            );
-          }),
-          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(
-                    ExpressionFactory.number(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),
-          ),
-        ),
-        ts.factory.createCallExpression(coalesce("integer"), undefined, [
-          ExpressionFactory.number(0),
-          ExpressionFactory.number(3),
-        ]),
-      ]);
-}
-
-interface IExplore {
-  function: boolean;
-  recursive: boolean;
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { Escaper } from "../../utils/Escaper";
+
+export namespace RandomJoiner {
+  export type Decoder = (meta: Metadata) => ts.Expression;
+
+  export const array =
+    (coalesce: (method: string) => ts.Expression) =>
+    (decoder: Decoder) =>
+    (explore: IExplore) =>
+    (length: ts.Expression | undefined) =>
+    (item: Metadata): ts.Expression => {
+      const generator: ts.Expression = ts.factory.createCallExpression(
+        coalesce("array"),
+        undefined,
+        [
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [],
+            undefined,
+            undefined,
+            decoder(item),
+          ),
+          ...(length ? [length] : []),
+        ],
+      );
+      if (explore.recursive === false) return generator;
+      return ts.factory.createConditionalExpression(
+        ts.factory.createGreaterThanEquals(
+          ExpressionFactory.number(5),
+          ts.factory.createIdentifier("_depth"),
+        ),
+        undefined,
+        generator,
+        undefined,
+        ts.factory.createArrayLiteralExpression([]),
+      );
+    };
+
+  export const tuple = (decoder: Decoder) => (elements: Metadata[]) =>
+    ts.factory.createArrayLiteralExpression(
+      elements.map((elem) => decoder(elem.rest ?? elem)),
+      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),
+            );
+          }),
+          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(
+                    ExpressionFactory.number(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),
+          ),
+        ),
+        ts.factory.createCallExpression(coalesce("integer"), undefined, [
+          ExpressionFactory.number(0),
+          ExpressionFactory.number(3),
+        ]),
+      ]);
+}
+
+interface IExplore {
+  function: boolean;
+  recursive: boolean;
+}