typia 7.0.0-dev.20241011 → 7.0.0-dev.20241012

package/src/factories/MetadataTypeTagSchemaFactory.ts

@@ -1,82 +1,82 @@
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-
-export namespace MetadataTypeTagSchemaFactory {
-  export const object = (props: {
-    report: (msg: string) => false;
-    object: MetadataObject;
-  }): object | undefined => {
-    if (props.object.recursive) {
-      props.report(`${props.object.name} has recursive type`);
-      return undefined;
-    }
-    const output: any = {};
-    for (const p of props.object.properties) {
-      const key: string | null = p.key.getSoleLiteral()!;
-      if (key === null) {
-        props.report(
-          `${props.object.name} has non-literal key type: ${p.key.getName()}`,
-        );
-        continue;
-      }
-      output[key] = iterate({
-        report: props.report,
-        object: props.object,
-        key,
-        metadata: p.value,
-      });
-    }
-    return output;
-  };
-
-  const iterate = (props: {
-    report: (message: string) => false;
-    object: MetadataObject;
-    key: string;
-    metadata: Metadata;
-  }): any => {
-    if (
-      props.metadata.any ||
-      props.metadata.atomics.length ||
-      props.metadata.arrays.length ||
-      props.metadata.natives.length ||
-      props.metadata.functions.length
-    )
-      props.report(`${props.object.name}.${props.key} has non-literal type`);
-    else if (props.metadata.size() > 1)
-      props.report(`${props.object.name}.${props.key} has union type`);
-    else if (props.metadata.size() === 0)
-      if (props.metadata.nullable) return null;
-      else if (props.metadata.isRequired() === true)
-        props.report(`${props.object.name}.${props.key} has non-literal type`);
-      else return undefined;
-    else if (props.metadata.constants.length)
-      return props.metadata.constants[0]!.values[0]!.value;
-    else if (props.metadata.tuples.length) {
-      const tuple = props.metadata.tuples[0]!;
-      if (tuple.type.isRest())
-        props.report(`${props.object.name}.${props.key} has rest tuple type`);
-      else if (tuple.type.recursive)
-        props.report(
-          `${props.object.name}.${props.key} has recursive tuple type`,
-        );
-      else if (tuple.type.elements.some((e) => e.required === false))
-        props.report(
-          `${props.object.name}.${props.key} has optional tuple type`,
-        );
-      return tuple.type.elements.map((elem) =>
-        iterate({
-          report: props.report,
-          object: props.object,
-          key: props.key,
-          metadata: elem,
-        }),
-      );
-    } else if (props.metadata.objects.length)
-      return object({
-        report: props.report,
-        object: props.metadata.objects[0]!,
-      });
-    else props.report(`${props.object.name}.${props.key} has non-literal type`);
-  };
-}
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+
+export namespace MetadataTypeTagSchemaFactory {
+  export const object = (props: {
+    report: (msg: string) => false;
+    object: MetadataObjectType;
+  }): object | undefined => {
+    if (props.object.recursive) {
+      props.report(`${props.object.name} has recursive type`);
+      return undefined;
+    }
+    const output: any = {};
+    for (const p of props.object.properties) {
+      const key: string | null = p.key.getSoleLiteral()!;
+      if (key === null) {
+        props.report(
+          `${props.object.name} has non-literal key type: ${p.key.getName()}`,
+        );
+        continue;
+      }
+      output[key] = iterate({
+        report: props.report,
+        object: props.object,
+        key,
+        metadata: p.value,
+      });
+    }
+    return output;
+  };
+
+  const iterate = (props: {
+    report: (message: string) => false;
+    object: MetadataObjectType;
+    key: string;
+    metadata: Metadata;
+  }): any => {
+    if (
+      props.metadata.any ||
+      props.metadata.atomics.length ||
+      props.metadata.arrays.length ||
+      props.metadata.natives.length ||
+      props.metadata.functions.length
+    )
+      props.report(`${props.object.name}.${props.key} has non-literal type`);
+    else if (props.metadata.size() > 1)
+      props.report(`${props.object.name}.${props.key} has union type`);
+    else if (props.metadata.size() === 0)
+      if (props.metadata.nullable) return null;
+      else if (props.metadata.isRequired() === true)
+        props.report(`${props.object.name}.${props.key} has non-literal type`);
+      else return undefined;
+    else if (props.metadata.constants.length)
+      return props.metadata.constants[0]!.values[0]!.value;
+    else if (props.metadata.tuples.length) {
+      const tuple = props.metadata.tuples[0]!;
+      if (tuple.type.isRest())
+        props.report(`${props.object.name}.${props.key} has rest tuple type`);
+      else if (tuple.type.recursive)
+        props.report(
+          `${props.object.name}.${props.key} has recursive tuple type`,
+        );
+      else if (tuple.type.elements.some((e) => e.required === false))
+        props.report(
+          `${props.object.name}.${props.key} has optional tuple type`,
+        );
+      return tuple.type.elements.map((elem) =>
+        iterate({
+          report: props.report,
+          object: props.object,
+          key: props.key,
+          metadata: elem,
+        }),
+      );
+    } else if (props.metadata.objects.length)
+      return object({
+        report: props.report,
+        object: props.metadata.objects[0]!.type,
+      });
+    else props.report(`${props.object.name}.${props.key} has non-literal type`);
+  };
+}

package/src/factories/NumericRangeFactory.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-
-import { ProtobufAtomic } from "../typings/ProtobufAtomic";
-
-import { ExpressionFactory } from "./ExpressionFactory";
-
-export namespace NumericRangeFactory {
-  export const number = (
-    type: ProtobufAtomic.Numeric,
-    input: ts.Expression,
-  ): ts.Expression => NumberPredicator[type](input);
-
-  export const bigint = (
-    type: ProtobufAtomic.BigNumeric,
-    input: ts.Expression,
-  ): ts.Expression => BigIntPredicator[type](input);
-}
-
-namespace NumberPredicator {
-  export const int32 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("-2147483648", "2147483647")(input),
-    );
-  export const uint32 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("0", "4294967295")(input),
-    );
-  export const int64 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("-9223372036854775808", "9223372036854775807")(input),
-    );
-  export const uint64 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("0", "18446744073709551615")(input),
-    );
-  export const float = (input: ts.Expression) =>
-    between("-1.175494351e38", "3.4028235e38")(input);
-  export const double = () => ts.factory.createTrue();
-}
-
-namespace BigIntPredicator {
-  export const int64 = () => ts.factory.createTrue();
-  export const uint64 = (input: ts.Expression) =>
-    ts.factory.createLessThanEquals(
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier("BigInt"),
-        undefined,
-        [ExpressionFactory.number(0)],
-      ),
-      input,
-    );
-}
-
-const integer = (input: ts.Expression) =>
-  ts.factory.createStrictEquality(
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier("Math.floor"),
-      undefined,
-      [input],
-    ),
-    input,
-  );
-
-const between = (x: string, y: string) => (input: ts.Expression) =>
-  ts.factory.createLogicalAnd(
-    ts.factory.createLessThanEquals(ts.factory.createIdentifier(x), input),
-    ts.factory.createLessThanEquals(input, ts.factory.createIdentifier(y)),
-  );
+import ts from "typescript";
+
+import { ProtobufAtomic } from "../typings/ProtobufAtomic";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+
+export namespace NumericRangeFactory {
+  export const number = (
+    type: ProtobufAtomic.Numeric,
+    input: ts.Expression,
+  ): ts.Expression => NumberPredicator[type](input);
+
+  export const bigint = (
+    type: ProtobufAtomic.BigNumeric,
+    input: ts.Expression,
+  ): ts.Expression => BigIntPredicator[type](input);
+}
+
+namespace NumberPredicator {
+  export const int32 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("-2147483648", "2147483647")(input),
+    );
+  export const uint32 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("0", "4294967295")(input),
+    );
+  export const int64 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("-9223372036854775808", "9223372036854775807")(input),
+    );
+  export const uint64 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("0", "18446744073709551615")(input),
+    );
+  export const float = (input: ts.Expression) =>
+    between("-1.175494351e38", "3.4028235e38")(input);
+  export const double = () => ts.factory.createTrue();
+}
+
+namespace BigIntPredicator {
+  export const int64 = () => ts.factory.createTrue();
+  export const uint64 = (input: ts.Expression) =>
+    ts.factory.createLessThanEquals(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("BigInt"),
+        undefined,
+        [ExpressionFactory.number(0)],
+      ),
+      input,
+    );
+}
+
+const integer = (input: ts.Expression) =>
+  ts.factory.createStrictEquality(
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier("Math.floor"),
+      undefined,
+      [input],
+    ),
+    input,
+  );
+
+const between = (x: string, y: string) => (input: ts.Expression) =>
+  ts.factory.createLogicalAnd(
+    ts.factory.createLessThanEquals(ts.factory.createIdentifier(x), input),
+    ts.factory.createLessThanEquals(input, ts.factory.createIdentifier(y)),
+  );

package/src/factories/ProtobufFactory.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 
 import { ProtobufUtil } from "../programmers/helpers/ProtobufUtil";
 
@@ -9,8 +9,6 @@ import { TransformerError } from "../transformers/TransformerError";
 
 import { ValidationPipe } from "../typings/ValidationPipe";
 
-import { Escaper } from "../utils/Escaper";
-
 import { MetadataCollection } from "./MetadataCollection";
 import { MetadataFactory } from "./MetadataFactory";
 
@@ -55,7 +53,7 @@ export namespace ProtobufFactory {
       const onlyObject: boolean =
         meta.size() === 1 &&
         meta.objects.length === 1 &&
-        meta.objects[0]!.properties.every((p) => p.key.isSoleLiteral()) &&
+        meta.objects[0]!.type.properties.every((p) => p.key.isSoleLiteral()) &&
         meta.isRequired() === true &&
         meta.nullable === false;
       if (onlyObject === false)
@@ -135,7 +133,7 @@ export namespace ProtobufFactory {
           a.type.value.maps.length ||
           (a.type.value.objects.length &&
             a.type.value.objects.some(
-              (o) => ProtobufUtil.isStaticObject(o) === false,
+              (o) => ProtobufUtil.isStaticObject(o.type) === false,
             )),
       )
     )
@@ -149,7 +147,7 @@ export namespace ProtobufFactory {
     // EMPTY PROPERTY
     if (
       meta.objects.length &&
-      meta.objects.some((obj) => obj.properties.length === 0)
+      meta.objects.some((obj) => obj.type.properties.length === 0)
     )
       noSupport("empty object type");
     // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
@@ -157,7 +155,7 @@ export namespace ProtobufFactory {
       meta.objects.length &&
       meta.objects.some(
         (obj) =>
-          obj.properties.filter((p) => !p.key.isSoleLiteral()).length > 1,
+          obj.type.properties.filter((p) => !p.key.isSoleLiteral()).length > 1,
       )
     )
       noSupport(
@@ -168,37 +166,25 @@ export namespace ProtobufFactory {
       meta.objects.length &&
       meta.objects.some(
         (obj) =>
-          obj.properties.some((p) => p.key.isSoleLiteral()) &&
-          obj.properties.some((p) => !p.key.isSoleLiteral()),
+          obj.type.properties.some((p) => p.key.isSoleLiteral()) &&
+          obj.type.properties.some((p) => !p.key.isSoleLiteral()),
       )
     )
       noSupport(
         "object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.",
       );
-    // STATIC PROPERTY, BUT INVALID KEY NAME
-    if (
-      meta.objects.length &&
-      meta.objects.some((obj) =>
-        obj.properties.some(
-          (p) =>
-            p.key.isSoleLiteral() === true &&
-            Escaper.variable(p.key.getSoleLiteral()!) === false,
-        ),
-      )
-    )
-      noSupport(`object type with invalid static key name.`);
     // DYNAMIC OBJECT, BUT PROPERTY VALUE TYPE IS ARRAY
     if (
       meta.objects.length &&
-      isDynamicObject(meta.objects[0]!) &&
-      meta.objects[0]!.properties.some((p) => !!p.value.arrays.length)
+      isDynamicObject(meta.objects[0]!.type) &&
+      meta.objects[0]!.type.properties.some((p) => !!p.value.arrays.length)
     )
       noSupport("dynamic object with array value type");
-    // UNION WITH DYNAMIC OBJECT
+    // UNION WITH DYNAMIC OBJECTa
     if (
       meta.size() > 1 &&
       meta.objects.length &&
-      isDynamicObject(meta.objects[0]!)
+      isDynamicObject(meta.objects[0]!.type)
     )
       noSupport("union type with dynamic object type");
     // UNION IN DYNAMIC PROPERTY VALUE
@@ -206,8 +192,8 @@ export namespace ProtobufFactory {
       meta.objects.length &&
       meta.objects.some(
         (obj) =>
-          isDynamicObject(obj) &&
-          obj.properties.some((p) => ProtobufUtil.isUnion(p.value)),
+          isDynamicObject(obj.type) &&
+          obj.type.properties.some((p) => ProtobufUtil.isUnion(p.value)),
       )
     )
       noSupport("union type in dynamic property");
@@ -245,7 +231,7 @@ export namespace ProtobufFactory {
   };
 }
 
-const isDynamicObject = (obj: MetadataObject): boolean =>
+const isDynamicObject = (obj: MetadataObjectType): boolean =>
   obj.properties[0]!.key.isSoleLiteral() === false;
 
 const BANNED_NATIVE_TYPES: Map<string, string | null> = new Map([

package/src/factories/StatementFactory.ts

@@ -1,90 +1,90 @@
-import ts from "typescript";
-
-import { TypeFactory } from "./TypeFactory";
-
-export namespace StatementFactory {
-  export const mut = (props: {
-    name: string;
-    type?: ts.TypeNode | undefined;
-    initializer?: ts.Expression | undefined;
-  }) =>
-    ts.factory.createVariableStatement(
-      undefined,
-      ts.factory.createVariableDeclarationList(
-        [
-          ts.factory.createVariableDeclaration(
-            props.name,
-            undefined,
-            props.type !== undefined
-              ? props.type
-              : props.initializer === undefined
-                ? TypeFactory.keyword("any")
-                : undefined,
-            props.initializer,
-          ),
-        ],
-        ts.NodeFlags.Let,
-      ),
-    );
-
-  export const constant = (props: {
-    name: string;
-    type?: ts.TypeNode | undefined;
-    value?: ts.Expression | undefined;
-  }) =>
-    ts.factory.createVariableStatement(
-      undefined,
-      ts.factory.createVariableDeclarationList(
-        [
-          ts.factory.createVariableDeclaration(
-            props.name,
-            undefined,
-            props.type !== undefined
-              ? props.type
-              : props.value === undefined
-                ? TypeFactory.keyword("any")
-                : undefined,
-            props.value,
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    );
-
-  export const entry = (props: { key: string; value: string }) =>
-    ts.factory.createVariableDeclarationList(
-      [
-        ts.factory.createVariableDeclaration(
-          ts.factory.createArrayBindingPattern([
-            ts.factory.createBindingElement(
-              undefined,
-              undefined,
-              ts.factory.createIdentifier(props.key),
-              undefined,
-            ),
-            ts.factory.createBindingElement(
-              undefined,
-              undefined,
-              ts.factory.createIdentifier(props.value),
-              undefined,
-            ),
-          ]),
-          undefined,
-          undefined,
-          undefined,
-        ),
-      ],
-      ts.NodeFlags.Const,
-    );
-
-  export const transpile = (script: string) =>
-    ts.factory.createExpressionStatement(
-      ts.factory.createIdentifier(ts.transpile(script)),
-    );
-
-  export const block = (expression: ts.Expression) =>
-    ts.factory.createBlock(
-      [ts.factory.createExpressionStatement(expression)],
-      true,
-    );
-}
+import ts from "typescript";
+
+import { TypeFactory } from "./TypeFactory";
+
+export namespace StatementFactory {
+  export const mut = (props: {
+    name: string;
+    type?: ts.TypeNode | undefined;
+    initializer?: ts.Expression | undefined;
+  }) =>
+    ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type !== undefined
+              ? props.type
+              : props.initializer === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.initializer,
+          ),
+        ],
+        ts.NodeFlags.Let,
+      ),
+    );
+
+  export const constant = (props: {
+    name: string;
+    type?: ts.TypeNode | undefined;
+    value?: ts.Expression | undefined;
+  }) =>
+    ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type !== undefined
+              ? props.type
+              : props.value === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.value,
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+
+  export const entry = (props: { key: string; value: string }) =>
+    ts.factory.createVariableDeclarationList(
+      [
+        ts.factory.createVariableDeclaration(
+          ts.factory.createArrayBindingPattern([
+            ts.factory.createBindingElement(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier(props.key),
+              undefined,
+            ),
+            ts.factory.createBindingElement(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier(props.value),
+              undefined,
+            ),
+          ]),
+          undefined,
+          undefined,
+          undefined,
+        ),
+      ],
+      ts.NodeFlags.Const,
+    );
+
+  export const transpile = (script: string) =>
+    ts.factory.createExpressionStatement(
+      ts.factory.createIdentifier(ts.transpile(script)),
+    );
+
+  export const block = (expression: ts.Expression) =>
+    ts.factory.createBlock(
+      [ts.factory.createExpressionStatement(expression)],
+      true,
+    );
+}