typia 7.0.0-dev.20241003 → 7.0.0-dev.20241005

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,148 +1,148 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-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 = (props: {
-    input: ts.Expression;
-    entries: IExpressionEntry[];
-    object: MetadataObject;
-  }): ts.ConciseBody => {
-    // PREPARE ASSETS
-    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
-    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
-
-    const statements: ts.Statement[] = regular
-      .map((entry) =>
-        ts.isBlock(entry.expression)
-          ? [...entry.expression.statements]
-          : [ts.factory.createExpressionStatement(entry.expression)],
-      )
-      .flat();
-    if (dynamic.length)
-      statements.push(
-        ts.factory.createExpressionStatement(
-          iterate_dynamic_properties({
-            regular,
-            dynamic,
-            input: props.input,
-          }),
-        ),
-      );
-
-    statements.push(prune_object_properties(props.object));
-    return ts.factory.createBlock(statements, true);
-  };
-
-  export const array = (props: {
-    input: ts.Expression;
-    arrow: ts.ArrowFunction;
-  }) =>
-    ts.factory.createCallExpression(
-      IdentifierFactory.access(props.input, "forEach"),
-      undefined,
-      [props.arrow],
-    );
-
-  export const tuple = (props: {
-    elements: ts.ConciseBody[];
-    rest: ts.ConciseBody | null;
-  }): ts.Block => {
-    const entire: ts.ConciseBody[] = [...props.elements];
-    if (props.rest !== null) entire.push(props.rest);
-
-    const statements: ts.Statement[] = entire
-      .map((elem) =>
-        ts.isBlock(elem)
-          ? [...elem.statements]
-          : [ts.factory.createExpressionStatement(elem)],
-      )
-      .flat();
-    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,
-        [props.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({
-                      top: true,
-                      metadata: 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 { 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 = (props: {
+    input: ts.Expression;
+    entries: IExpressionEntry[];
+    object: MetadataObject;
+  }): ts.ConciseBody => {
+    // PREPARE ASSETS
+    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
+
+    const statements: ts.Statement[] = regular
+      .map((entry) =>
+        ts.isBlock(entry.expression)
+          ? [...entry.expression.statements]
+          : [ts.factory.createExpressionStatement(entry.expression)],
+      )
+      .flat();
+    if (dynamic.length)
+      statements.push(
+        ts.factory.createExpressionStatement(
+          iterate_dynamic_properties({
+            regular,
+            dynamic,
+            input: props.input,
+          }),
+        ),
+      );
+
+    statements.push(prune_object_properties(props.object));
+    return ts.factory.createBlock(statements, true);
+  };
+
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.ArrowFunction;
+  }) =>
+    ts.factory.createCallExpression(
+      IdentifierFactory.access(props.input, "forEach"),
+      undefined,
+      [props.arrow],
+    );
+
+  export const tuple = (props: {
+    elements: ts.ConciseBody[];
+    rest: ts.ConciseBody | null;
+  }): ts.Block => {
+    const entire: ts.ConciseBody[] = [...props.elements];
+    if (props.rest !== null) entire.push(props.rest);
+
+    const statements: ts.Statement[] = entire
+      .map((elem) =>
+        ts.isBlock(elem)
+          ? [...elem.statements]
+          : [ts.factory.createExpressionStatement(elem)],
+      )
+      .flat();
+    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,
+        [props.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({
+                      top: true,
+                      metadata: 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,162 +1,162 @@
-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 = (metadata: Metadata) => ts.Expression;
-
-  export const array = (props: {
-    coalesce: (method: string) => ts.Expression;
-    decode: Decoder;
-    explore: IExplore;
-    length: ts.Expression | undefined;
-    unique: ts.Expression | undefined;
-    metadata: Metadata;
-  }): ts.Expression => {
-    const generator: ts.Expression = ts.factory.createCallExpression(
-      props.coalesce("array"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [],
-          undefined,
-          undefined,
-          props.decode(props.metadata),
-        ),
-        ...(props.length
-          ? [props.length]
-          : props.unique
-            ? [ts.factory.createIdentifier("undefined")]
-            : []),
-        ...(props.unique ? [props.unique] : []),
-      ],
-    );
-    if (props.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 = (props: {
-    decode: Decoder;
-    elements: Metadata[];
-  }): ts.ArrayLiteralExpression =>
-    ts.factory.createArrayLiteralExpression(
-      props.elements.map((elem) => props.decode(elem.rest ?? elem)),
-      true,
-    );
-
-  export const object = (props: {
-    coalesce: (method: string) => ts.Expression;
-    decode: Decoder;
-    object: MetadataObject;
-  }): ts.ConciseBody => {
-    if (props.object.properties.length === 0)
-      return ts.factory.createIdentifier("{}");
-
-    // LIST UP PROPERTIES
-    const regular = props.object.properties.filter((p) =>
-      p.key.isSoleLiteral(),
-    );
-    const dynamic = props.object.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),
-            props.decode(p.value),
-          );
-        }),
-        true,
-      );
-    if (dynamic.length === 0) return literal;
-
-    const properties: ts.Statement[] = dynamic.map((p) =>
-      ts.factory.createExpressionStatement(
-        dynamicProperty({
-          coalesce: props.coalesce,
-          decode: props.decode,
-          property: p,
-        }),
-      ),
-    );
-    return ts.factory.createBlock(
-      [
-        StatementFactory.constant({
-          name: "output",
-          value: ts.factory.createAsExpression(
-            literal,
-            TypeFactory.keyword("any"),
-          ),
-        }),
-        ...(props.object.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 = (props: {
-    coalesce: (method: string) => ts.Expression;
-    decode: Decoder;
-    property: MetadataProperty;
-  }) =>
-    ts.factory.createCallExpression(props.coalesce("array"), undefined, [
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [],
-        undefined,
-        undefined,
-        ts.factory.createBinaryExpression(
-          ts.factory.createElementAccessExpression(
-            ts.factory.createIdentifier("output"),
-            props.decode(props.property.key),
-          ),
-          ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-          props.decode(props.property.value),
-        ),
-      ),
-      ts.factory.createCallExpression(props.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 = (metadata: Metadata) => ts.Expression;
+
+  export const array = (props: {
+    coalesce: (method: string) => ts.Expression;
+    decode: Decoder;
+    explore: IExplore;
+    length: ts.Expression | undefined;
+    unique: ts.Expression | undefined;
+    metadata: Metadata;
+  }): ts.Expression => {
+    const generator: ts.Expression = ts.factory.createCallExpression(
+      props.coalesce("array"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [],
+          undefined,
+          undefined,
+          props.decode(props.metadata),
+        ),
+        ...(props.length
+          ? [props.length]
+          : props.unique
+            ? [ts.factory.createIdentifier("undefined")]
+            : []),
+        ...(props.unique ? [props.unique] : []),
+      ],
+    );
+    if (props.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 = (props: {
+    decode: Decoder;
+    elements: Metadata[];
+  }): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(
+      props.elements.map((elem) => props.decode(elem.rest ?? elem)),
+      true,
+    );
+
+  export const object = (props: {
+    coalesce: (method: string) => ts.Expression;
+    decode: Decoder;
+    object: MetadataObject;
+  }): ts.ConciseBody => {
+    if (props.object.properties.length === 0)
+      return ts.factory.createIdentifier("{}");
+
+    // LIST UP PROPERTIES
+    const regular = props.object.properties.filter((p) =>
+      p.key.isSoleLiteral(),
+    );
+    const dynamic = props.object.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),
+            props.decode(p.value),
+          );
+        }),
+        true,
+      );
+    if (dynamic.length === 0) return literal;
+
+    const properties: ts.Statement[] = dynamic.map((p) =>
+      ts.factory.createExpressionStatement(
+        dynamicProperty({
+          coalesce: props.coalesce,
+          decode: props.decode,
+          property: p,
+        }),
+      ),
+    );
+    return ts.factory.createBlock(
+      [
+        StatementFactory.constant({
+          name: "output",
+          value: ts.factory.createAsExpression(
+            literal,
+            TypeFactory.keyword("any"),
+          ),
+        }),
+        ...(props.object.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 = (props: {
+    coalesce: (method: string) => ts.Expression;
+    decode: Decoder;
+    property: MetadataProperty;
+  }) =>
+    ts.factory.createCallExpression(props.coalesce("array"), undefined, [
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        undefined,
+        ts.factory.createBinaryExpression(
+          ts.factory.createElementAccessExpression(
+            ts.factory.createIdentifier("output"),
+            props.decode(props.property.key),
+          ),
+          ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+          props.decode(props.property.value),
+        ),
+      ),
+      ts.factory.createCallExpression(props.coalesce("integer"), undefined, [
+        ExpressionFactory.number(0),
+        ExpressionFactory.number(3),
+      ]),
+    ]);
+}
+
+interface IExplore {
+  function: boolean;
+  recursive: boolean;
+}