typia 7.0.0-dev.20241010 → 7.0.0-dev.20241011

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -1,145 +1,145 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
-
-export const iterate_metadata_collection = (props: {
-  errors: MetadataFactory.IError[];
-  collection: MetadataCollection;
-}): void => {
-  for (const array of props.collection.arrays())
-    if (array.recursive === null)
-      props.collection.setArrayRecursive(
-        array,
-        isArrayRecursive({
-          visited: new Set(),
-          array,
-          metadata: array.value,
-        }),
-      );
-  for (const tuple of props.collection.tuples())
-    if (tuple.recursive === null) {
-      const visited: Set<Metadata> = new Set();
-      props.collection.setTupleRecursive(
-        tuple,
-        tuple.elements.some((e) =>
-          isTupleRecursive({
-            visited,
-            tuple,
-            metadata: e,
-          }),
-        ),
-      );
-    }
-  for (const object of props.collection.objects()) {
-    iterate_metadata_comment_tags({
-      errors: props.errors,
-      object,
-    });
-    if (object.recursive === null) {
-      const visited: Set<Metadata> = new Set();
-      props.collection.setObjectRecursive(
-        object,
-        object.properties.some((p) =>
-          isObjectRecursive({
-            visited,
-            object,
-            metadata: p.value,
-          }),
-        ),
-      );
-    }
-  }
-};
-
-const isArrayRecursive = (props: {
-  visited: Set<Metadata>;
-  array: MetadataArrayType;
-  metadata: Metadata;
-}): boolean => {
-  if (props.visited.has(props.metadata)) return false;
-  props.visited.add(props.metadata);
-
-  const next = (metadata: Metadata): boolean =>
-    isArrayRecursive({
-      ...props,
-      metadata,
-    });
-  return (
-    props.metadata.arrays.some(
-      (a) => a.type === props.array || next(a.type.value),
-    ) ||
-    props.metadata.aliases.some((alias) => next(alias.value)) ||
-    props.metadata.tuples.some(
-      (t) => !t.type.recursive && t.type.elements.some(next),
-    ) ||
-    props.metadata.maps.some((m) => next(m.value)) ||
-    props.metadata.sets.some(next) ||
-    (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
-    (props.metadata.rest !== null && next(props.metadata.rest))
-  );
-};
-
-const isTupleRecursive = (props: {
-  visited: Set<Metadata>;
-  tuple: MetadataTupleType;
-  metadata: Metadata;
-}): boolean => {
-  if (props.visited.has(props.metadata)) return false;
-  props.visited.add(props.metadata);
-
-  const next = (metadata: Metadata): boolean =>
-    isTupleRecursive({
-      ...props,
-      metadata,
-    });
-  return (
-    props.metadata.tuples.some(
-      (t) => t.type === props.tuple || t.type.elements.some(next),
-    ) ||
-    props.metadata.arrays.some(
-      (a) => !a.type.recursive && next(a.type.value),
-    ) ||
-    props.metadata.maps.some((m) => next(m.value)) ||
-    props.metadata.sets.some((s) => next(s)) ||
-    props.metadata.aliases.some((alias) => next(alias.value)) ||
-    (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
-    (props.metadata.rest !== null && next(props.metadata.rest))
-  );
-};
-
-const isObjectRecursive = (props: {
-  visited: Set<Metadata>;
-  object: MetadataObject;
-  metadata: Metadata;
-}): boolean => {
-  if (props.visited.has(props.metadata)) return false;
-  props.visited.add(props.metadata);
-
-  const next = (metadata: Metadata): boolean =>
-    isObjectRecursive({
-      ...props,
-      metadata,
-    });
-  return (
-    props.metadata.objects.some(
-      (o) =>
-        props.object === o || o.properties.some((prop) => next(prop.value)),
-    ) ||
-    props.metadata.aliases.some((alias) => next(alias.value)) ||
-    props.metadata.arrays.some(
-      (array) => !array.type.recursive && next(array.type.value),
-    ) ||
-    props.metadata.tuples.some(
-      (tuple) => !tuple.type.recursive && tuple.type.elements.some(next),
-    ) ||
-    props.metadata.maps.some((map) => next(map.value)) ||
-    props.metadata.sets.some(next) ||
-    (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
-    (props.metadata.rest !== null && next(props.metadata.rest))
-  );
-};
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
+
+export const iterate_metadata_collection = (props: {
+  errors: MetadataFactory.IError[];
+  collection: MetadataCollection;
+}): void => {
+  for (const array of props.collection.arrays())
+    if (array.recursive === null)
+      props.collection.setArrayRecursive(
+        array,
+        isArrayRecursive({
+          visited: new Set(),
+          array,
+          metadata: array.value,
+        }),
+      );
+  for (const tuple of props.collection.tuples())
+    if (tuple.recursive === null) {
+      const visited: Set<Metadata> = new Set();
+      props.collection.setTupleRecursive(
+        tuple,
+        tuple.elements.some((e) =>
+          isTupleRecursive({
+            visited,
+            tuple,
+            metadata: e,
+          }),
+        ),
+      );
+    }
+  for (const object of props.collection.objects()) {
+    iterate_metadata_comment_tags({
+      errors: props.errors,
+      object,
+    });
+    if (object.recursive === null) {
+      const visited: Set<Metadata> = new Set();
+      props.collection.setObjectRecursive(
+        object,
+        object.properties.some((p) =>
+          isObjectRecursive({
+            visited,
+            object,
+            metadata: p.value,
+          }),
+        ),
+      );
+    }
+  }
+};
+
+const isArrayRecursive = (props: {
+  visited: Set<Metadata>;
+  array: MetadataArrayType;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
+
+  const next = (metadata: Metadata): boolean =>
+    isArrayRecursive({
+      ...props,
+      metadata,
+    });
+  return (
+    props.metadata.arrays.some(
+      (a) => a.type === props.array || next(a.type.value),
+    ) ||
+    props.metadata.aliases.some((alias) => next(alias.value)) ||
+    props.metadata.tuples.some(
+      (t) => !t.type.recursive && t.type.elements.some(next),
+    ) ||
+    props.metadata.maps.some((m) => next(m.value)) ||
+    props.metadata.sets.some(next) ||
+    (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
+    (props.metadata.rest !== null && next(props.metadata.rest))
+  );
+};
+
+const isTupleRecursive = (props: {
+  visited: Set<Metadata>;
+  tuple: MetadataTupleType;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
+
+  const next = (metadata: Metadata): boolean =>
+    isTupleRecursive({
+      ...props,
+      metadata,
+    });
+  return (
+    props.metadata.tuples.some(
+      (t) => t.type === props.tuple || t.type.elements.some(next),
+    ) ||
+    props.metadata.arrays.some(
+      (a) => !a.type.recursive && next(a.type.value),
+    ) ||
+    props.metadata.maps.some((m) => next(m.value)) ||
+    props.metadata.sets.some((s) => next(s)) ||
+    props.metadata.aliases.some((alias) => next(alias.value)) ||
+    (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
+    (props.metadata.rest !== null && next(props.metadata.rest))
+  );
+};
+
+const isObjectRecursive = (props: {
+  visited: Set<Metadata>;
+  object: MetadataObject;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
+
+  const next = (metadata: Metadata): boolean =>
+    isObjectRecursive({
+      ...props,
+      metadata,
+    });
+  return (
+    props.metadata.objects.some(
+      (o) =>
+        props.object === o || o.properties.some((prop) => next(prop.value)),
+    ) ||
+    props.metadata.aliases.some((alias) => next(alias.value)) ||
+    props.metadata.arrays.some(
+      (array) => !array.type.recursive && next(array.type.value),
+    ) ||
+    props.metadata.tuples.some(
+      (tuple) => !tuple.type.recursive && tuple.type.elements.some(next),
+    ) ||
+    props.metadata.maps.some((map) => next(map.value)) ||
+    props.metadata.sets.some(next) ||
+    (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
+    (props.metadata.rest !== null && next(props.metadata.rest))
+  );
+};

package/src/factories/internal/metadata/iterate_metadata_comment_tags.ts

@@ -1,32 +1,32 @@
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-
-import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
-import { MetadataFactory } from "../../MetadataFactory";
-
-export const iterate_metadata_comment_tags = (props: {
-  errors: MetadataFactory.IError[];
-  object: MetadataObject;
-}) => {
-  if (props.object.tagged_ === true) return;
-  props.object.tagged_ = true;
-
-  for (const property of props.object.properties) {
-    MetadataCommentTagFactory.analyze({
-      errors: props.errors,
-      metadata: property.value,
-      tags: property.jsDocTags,
-      explore: {
-        top: false,
-        object: props.object,
-        property: property.key.isSoleLiteral()
-          ? property.key.getSoleLiteral()!
-          : {},
-        parameter: null,
-        nested: null,
-        aliased: false,
-        escaped: false,
-        output: false,
-      },
-    });
-  }
-};
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+
+import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
+import { MetadataFactory } from "../../MetadataFactory";
+
+export const iterate_metadata_comment_tags = (props: {
+  errors: MetadataFactory.IError[];
+  object: MetadataObject;
+}) => {
+  if (props.object.tagged_ === true) return;
+  props.object.tagged_ = true;
+
+  for (const property of props.object.properties) {
+    MetadataCommentTagFactory.analyze({
+      errors: props.errors,
+      metadata: property.value,
+      tags: property.jsDocTags,
+      explore: {
+        top: false,
+        object: props.object,
+        property: property.key.isSoleLiteral()
+          ? property.key.getSoleLiteral()!
+          : {},
+        parameter: null,
+        nested: null,
+        aliased: false,
+        escaped: false,
+        output: false,
+      },
+    });
+  }
+};

package/src/factories/internal/metadata/iterate_metadata_function.ts

@@ -1,88 +1,88 @@
-import ts from "typescript";
-
-import { FunctionalGeneralProgrammer } from "../../../programmers/functional/internal/FunctionalGeneralProgrammer";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataFunction } from "../../../schemas/metadata/MetadataFunction";
-import { MetadataParameter } from "../../../schemas/metadata/MetadataParameter";
-
-import { CommentFactory } from "../../CommentFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_function = (
-  props: IMetadataIteratorProps,
-): boolean => {
-  const declaration: ts.SignatureDeclaration | null = TypeFactory.getFunction(
-    props.type,
-  );
-  if (declaration === null) return false;
-  else if (!props.options.functional) {
-    if (props.metadata.functions.length === 0)
-      props.metadata.functions.push(
-        MetadataFunction.create({
-          parameters: [],
-          output: Metadata.initialize(),
-          async: false,
-        }),
-      );
-  } else {
-    const [signature] = props.type.getCallSignatures();
-    if (signature === undefined || signature.declaration === undefined)
-      props.metadata.functions.push(
-        MetadataFunction.create({
-          parameters: [],
-          output: Metadata.initialize(),
-          async: false,
-        }),
-      );
-    else {
-      const { async }: FunctionalGeneralProgrammer.IOutput =
-        FunctionalGeneralProgrammer.getReturnType({
-          checker: props.checker,
-          declaration,
-        });
-      props.metadata.functions.push(
-        MetadataFunction.create({
-          parameters: signature.parameters.map((p) =>
-            MetadataParameter.create({
-              name: p.name,
-              type: explore_metadata({
-                ...props,
-                type: props.checker.getTypeOfSymbol(p),
-                explore: {
-                  ...props.explore,
-                  top: false,
-                  parameter: p.name,
-                },
-              }),
-              description: CommentFactory.description(p) ?? null,
-              jsDocTags: p?.getJsDocTags() ?? [],
-            }),
-          ),
-          async,
-          output: explore_metadata({
-            ...props,
-            options: {
-              ...props.options,
-              functional: false,
-            },
-            type: async
-              ? (props.checker.getTypeArguments(
-                  signature.getReturnType() as ts.TypeReference,
-                )?.[0] ??
-                props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
-              : signature.getReturnType(),
-            explore: {
-              ...props.explore,
-              top: false,
-              output: true,
-            },
-          }),
-        }),
-      );
-    }
-  }
-  return true;
-};
+import ts from "typescript";
+
+import { FunctionalGeneralProgrammer } from "../../../programmers/functional/internal/FunctionalGeneralProgrammer";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataFunction } from "../../../schemas/metadata/MetadataFunction";
+import { MetadataParameter } from "../../../schemas/metadata/MetadataParameter";
+
+import { CommentFactory } from "../../CommentFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_function = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const declaration: ts.SignatureDeclaration | null = TypeFactory.getFunction(
+    props.type,
+  );
+  if (declaration === null) return false;
+  else if (!props.options.functional) {
+    if (props.metadata.functions.length === 0)
+      props.metadata.functions.push(
+        MetadataFunction.create({
+          parameters: [],
+          output: Metadata.initialize(),
+          async: false,
+        }),
+      );
+  } else {
+    const [signature] = props.type.getCallSignatures();
+    if (signature === undefined || signature.declaration === undefined)
+      props.metadata.functions.push(
+        MetadataFunction.create({
+          parameters: [],
+          output: Metadata.initialize(),
+          async: false,
+        }),
+      );
+    else {
+      const { async }: FunctionalGeneralProgrammer.IOutput =
+        FunctionalGeneralProgrammer.getReturnType({
+          checker: props.checker,
+          declaration,
+        });
+      props.metadata.functions.push(
+        MetadataFunction.create({
+          parameters: signature.parameters.map((p) =>
+            MetadataParameter.create({
+              name: p.name,
+              type: explore_metadata({
+                ...props,
+                type: props.checker.getTypeOfSymbol(p),
+                explore: {
+                  ...props.explore,
+                  top: false,
+                  parameter: p.name,
+                },
+              }),
+              description: CommentFactory.description(p) ?? null,
+              jsDocTags: p?.getJsDocTags() ?? [],
+            }),
+          ),
+          async,
+          output: explore_metadata({
+            ...props,
+            options: {
+              ...props.options,
+              functional: false,
+            },
+            type: async
+              ? (props.checker.getTypeArguments(
+                  signature.getReturnType() as ts.TypeReference,
+                )?.[0] ??
+                props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
+              : signature.getReturnType(),
+            explore: {
+              ...props.explore,
+              top: false,
+              output: true,
+            },
+          }),
+        }),
+      );
+    }
+  }
+  return true;
+};

package/src/internal/{$httpParameterBigint.ts → $httpParameterReadBigint.ts}

@@ -1,4 +1,4 @@
-export const $httpParameterBigint = (value: string) =>
+export const $httpParameterReadBigint = (value: string) =>
   value !== "null" ? toBigint(value) : null;
 
 const toBigint = (str: string): bigint | string => {

package/src/internal/{$httpParameterBoolean.ts → $httpParameterReadBoolean.ts}

@@ -1,4 +1,4 @@
-export const $httpParameterBoolean = (value: string) =>
+export const $httpParameterReadBoolean = (value: string) =>
   value !== "null"
     ? value === "true" || value === "1"
       ? true

package/src/internal/{$httpParameterNumber.ts → $httpParameterReadNumber.ts}

@@ -1,4 +1,4 @@
-export const $httpParameterNumber = (value: string) =>
+export const $httpParameterReadNumber = (value: string) =>
   value !== "null" ? toNumber(value) : null;
 
 const toNumber = (str: string): number | string => {

package/src/internal/$httpParameterReadString.ts

@@ -0,0 +1,2 @@
+export const $httpParameterReadString = (value: string) =>
+  value !== "null" ? value : null;