typia 5.5.7 → 5.5.8

package/src/factories/MetadataTypeTagSchemaFactory.ts

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