typia 7.2.1 → 7.3.0-dev.20241213

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,148 +1,148 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
-
-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: MetadataObjectType;
-  }): 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 { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+
+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: MetadataObjectType;
+  }): 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,168 +1,168 @@
-import { OpenApi } from "@samchon/openapi";
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { LiteralFactory } from "../../factories/LiteralFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
-import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
-
-import { Escaper } from "../../utils/Escaper";
-
-export namespace RandomJoiner {
-  export type Decoder = (metadata: Metadata) => ts.Expression;
-
-  export const array = (props: {
-    decode: Decoder;
-    recursive: boolean;
-    expression: ts.Expression;
-    array: MetadataArrayType;
-    schema: Omit<OpenApi.IJsonSchema.IArray, "items"> | undefined;
-  }): ts.Expression => {
-    const call: ts.Expression = ts.factory.createCallExpression(
-      props.expression,
-      undefined,
-      [
-        ts.factory.createObjectLiteralExpression(
-          [
-            ...(props.schema
-              ? Object.entries(props.schema)
-                  .filter(([key]) => key !== "items")
-                  .map(([key, value]) =>
-                    ts.factory.createPropertyAssignment(
-                      IdentifierFactory.identifier(key),
-                      LiteralFactory.write(value),
-                    ),
-                  )
-              : []),
-            ...(props.schema
-              ? []
-              : [
-                  ts.factory.createSpreadAssignment(
-                    ts.factory.createIdentifier("_schema"),
-                  ),
-                ]),
-            ts.factory.createPropertyAssignment(
-              "element",
-              ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [],
-                undefined,
-                undefined,
-                props.decode(props.array.value),
-              ),
-            ),
-          ],
-          true,
-        ),
-      ],
-    );
-    if (props.recursive === false) return call;
-    return ts.factory.createConditionalExpression(
-      ts.factory.createGreaterThanEquals(
-        ExpressionFactory.number(5),
-        ts.factory.createIdentifier("_depth"),
-      ),
-      undefined,
-      call,
-      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: {
-    decode: Decoder;
-    object: MetadataObjectType;
-  }): ts.ConciseBody => {
-    if (props.object.properties.length === 0) return LiteralFactory.write({});
-
-    // LIST UP PROPERTIES
-    const regular = props.object.properties.filter((p) =>
-      p.key.isSoleLiteral(),
-    );
-    const dynamic = props.object.properties.filter(
-      (p) => !p.key.isSoleLiteral(),
-    );
-
-    return 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),
-          );
-        }),
-        ...dynamic.map((property) =>
-          ts.factory.createSpreadAssignment(
-            dynamicProperty({
-              decode: props.decode,
-              property: property,
-            }),
-          ),
-        ),
-      ],
-      true,
-    );
-  };
-
-  const dynamicProperty = (props: {
-    decode: Decoder;
-    property: MetadataProperty;
-  }) => {
-    const tuple: MetadataTuple = MetadataTuple.create({
-      type: MetadataTupleType.create({
-        name: `[${props.property.key.getName()}, ${props.property.value.getName()}]`,
-        elements: [props.property.key, props.property.value],
-        index: null,
-        recursive: false,
-        nullables: [false],
-      }),
-      tags: [],
-    });
-    const array: MetadataArray = MetadataArray.create({
-      type: MetadataArrayType.create({
-        name: `Array<[${props.property.key.getName()}, ${props.property.value.getName()}]>`,
-        value: Metadata.create({
-          ...Metadata.initialize(),
-          tuples: [tuple],
-        }),
-        nullables: [false],
-        recursive: false,
-        index: null,
-      }),
-      tags: [[]],
-    });
-    return ts.factory.createCallExpression(
-      IdentifierFactory.access(
-        ts.factory.createIdentifier("Object"),
-        "fromEntries",
-      ),
-      undefined,
-      [
-        props.decode(
-          Metadata.create({
-            ...Metadata.initialize(),
-            arrays: [array],
-          }),
-        ),
-      ],
-    );
-  };
-}
+import { OpenApi } from "@samchon/openapi";
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
+
+import { Escaper } from "../../utils/Escaper";
+
+export namespace RandomJoiner {
+  export type Decoder = (metadata: Metadata) => ts.Expression;
+
+  export const array = (props: {
+    decode: Decoder;
+    recursive: boolean;
+    expression: ts.Expression;
+    array: MetadataArrayType;
+    schema: Omit<OpenApi.IJsonSchema.IArray, "items"> | undefined;
+  }): ts.Expression => {
+    const call: ts.Expression = ts.factory.createCallExpression(
+      props.expression,
+      undefined,
+      [
+        ts.factory.createObjectLiteralExpression(
+          [
+            ...(props.schema
+              ? Object.entries(props.schema)
+                  .filter(([key]) => key !== "items")
+                  .map(([key, value]) =>
+                    ts.factory.createPropertyAssignment(
+                      IdentifierFactory.identifier(key),
+                      LiteralFactory.write(value),
+                    ),
+                  )
+              : []),
+            ...(props.schema
+              ? []
+              : [
+                  ts.factory.createSpreadAssignment(
+                    ts.factory.createIdentifier("_schema"),
+                  ),
+                ]),
+            ts.factory.createPropertyAssignment(
+              "element",
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                undefined,
+                props.decode(props.array.value),
+              ),
+            ),
+          ],
+          true,
+        ),
+      ],
+    );
+    if (props.recursive === false) return call;
+    return ts.factory.createConditionalExpression(
+      ts.factory.createGreaterThanEquals(
+        ExpressionFactory.number(5),
+        ts.factory.createIdentifier("_depth"),
+      ),
+      undefined,
+      call,
+      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: {
+    decode: Decoder;
+    object: MetadataObjectType;
+  }): ts.ConciseBody => {
+    if (props.object.properties.length === 0) return LiteralFactory.write({});
+
+    // LIST UP PROPERTIES
+    const regular = props.object.properties.filter((p) =>
+      p.key.isSoleLiteral(),
+    );
+    const dynamic = props.object.properties.filter(
+      (p) => !p.key.isSoleLiteral(),
+    );
+
+    return 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),
+          );
+        }),
+        ...dynamic.map((property) =>
+          ts.factory.createSpreadAssignment(
+            dynamicProperty({
+              decode: props.decode,
+              property: property,
+            }),
+          ),
+        ),
+      ],
+      true,
+    );
+  };
+
+  const dynamicProperty = (props: {
+    decode: Decoder;
+    property: MetadataProperty;
+  }) => {
+    const tuple: MetadataTuple = MetadataTuple.create({
+      type: MetadataTupleType.create({
+        name: `[${props.property.key.getName()}, ${props.property.value.getName()}]`,
+        elements: [props.property.key, props.property.value],
+        index: null,
+        recursive: false,
+        nullables: [false],
+      }),
+      tags: [],
+    });
+    const array: MetadataArray = MetadataArray.create({
+      type: MetadataArrayType.create({
+        name: `Array<[${props.property.key.getName()}, ${props.property.value.getName()}]>`,
+        value: Metadata.create({
+          ...Metadata.initialize(),
+          tuples: [tuple],
+        }),
+        nullables: [false],
+        recursive: false,
+        index: null,
+      }),
+      tags: [[]],
+    });
+    return ts.factory.createCallExpression(
+      IdentifierFactory.access(
+        ts.factory.createIdentifier("Object"),
+        "fromEntries",
+      ),
+      undefined,
+      [
+        props.decode(
+          Metadata.create({
+            ...Metadata.initialize(),
+            arrays: [array],
+          }),
+        ),
+      ],
+    );
+  };
+}