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

package/src/factories/TemplateFactory.ts

@@ -1,64 +1,64 @@
-import ts from "typescript";
-
-export namespace TemplateFactory {
-  export const generate = (expressions: ts.Expression[]): ts.Expression => {
-    if (expressions.every((exp) => ts.isStringLiteral(exp)))
-      return ts.factory.createStringLiteral(
-        (expressions as ts.StringLiteral[]).map((str) => str.text).join(""),
-      );
-
-    const iterator: IIterator = {
-      value: "",
-      index: 0,
-    };
-    gather({
-      expressions,
-      iterator,
-    });
-
-    const head: ts.TemplateHead = ts.factory.createTemplateHead(iterator.value);
-    const spans: ts.TemplateSpan[] = [];
-
-    while (true) {
-      const elem: ts.Expression = expressions[iterator.index++]!;
-      gather({
-        expressions,
-        iterator,
-      });
-
-      const broken: boolean = iterator.index === expressions.length;
-      spans.push(
-        ts.factory.createTemplateSpan(
-          elem,
-          broken
-            ? ts.factory.createTemplateTail(iterator.value)
-            : ts.factory.createTemplateMiddle(iterator.value),
-        ),
-      );
-      if (broken === true) break;
-    }
-    return ts.factory.createTemplateExpression(head, spans);
-  };
-
-  const gather = (props: {
-    expressions: ts.Expression[];
-    iterator: IIterator;
-  }): void => {
-    const found: number = props.expressions.findIndex(
-      (elem, index) =>
-        index >= props.iterator.index && !ts.isStringLiteral(elem),
-    );
-
-    const last: number = found !== -1 ? found : props.expressions.length;
-    props.iterator.value = props.expressions
-      .slice(props.iterator.index, last)
-      .map((elem) => (elem as ts.StringLiteral).text)
-      .reduce((x, y) => x + y, "");
-    props.iterator.index = last;
-  };
-
-  interface IIterator {
-    value: string;
-    index: number;
-  }
-}
+import ts from "typescript";
+
+export namespace TemplateFactory {
+  export const generate = (expressions: ts.Expression[]): ts.Expression => {
+    if (expressions.every((exp) => ts.isStringLiteral(exp)))
+      return ts.factory.createStringLiteral(
+        (expressions as ts.StringLiteral[]).map((str) => str.text).join(""),
+      );
+
+    const iterator: IIterator = {
+      value: "",
+      index: 0,
+    };
+    gather({
+      expressions,
+      iterator,
+    });
+
+    const head: ts.TemplateHead = ts.factory.createTemplateHead(iterator.value);
+    const spans: ts.TemplateSpan[] = [];
+
+    while (true) {
+      const elem: ts.Expression = expressions[iterator.index++]!;
+      gather({
+        expressions,
+        iterator,
+      });
+
+      const broken: boolean = iterator.index === expressions.length;
+      spans.push(
+        ts.factory.createTemplateSpan(
+          elem,
+          broken
+            ? ts.factory.createTemplateTail(iterator.value)
+            : ts.factory.createTemplateMiddle(iterator.value),
+        ),
+      );
+      if (broken === true) break;
+    }
+    return ts.factory.createTemplateExpression(head, spans);
+  };
+
+  const gather = (props: {
+    expressions: ts.Expression[];
+    iterator: IIterator;
+  }): void => {
+    const found: number = props.expressions.findIndex(
+      (elem, index) =>
+        index >= props.iterator.index && !ts.isStringLiteral(elem),
+    );
+
+    const last: number = found !== -1 ? found : props.expressions.length;
+    props.iterator.value = props.expressions
+      .slice(props.iterator.index, last)
+      .map((elem) => (elem as ts.StringLiteral).text)
+      .reduce((x, y) => x + y, "");
+    props.iterator.index = last;
+  };
+
+  interface IIterator {
+    value: string;
+    index: number;
+  }
+}

package/src/factories/TypeFactory.ts

@@ -1,140 +1,140 @@
-import ts from "typescript";
-
-export namespace TypeFactory {
-  export const isFunction = (type: ts.Type): boolean =>
-    getFunction(type) !== null;
-
-  export const getFunction = (type: ts.Type) => {
-    const node = type.symbol?.declarations?.[0];
-    if (node === undefined) return null;
-
-    return ts.isFunctionLike(node)
-      ? node
-      : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
-        ? ts.isFunctionLike(node.initializer)
-          ? node.initializer
-          : null
-        : null;
-  };
-
-  export const getReturnTypeOfClassMethod = (props: {
-    checker: ts.TypeChecker;
-    class: ts.Type;
-    function: string;
-  }): ts.Type | null => {
-    // FIND TO-JSON METHOD
-    const symbol: ts.Symbol | undefined = props.class.getProperty(
-      props.function,
-    );
-    if (!symbol) return null;
-    else if (!symbol.valueDeclaration) return null;
-
-    // GET FUNCTION DECLARATION
-    const functor: ts.Type = props.checker.getTypeOfSymbolAtLocation(
-      symbol,
-      symbol.valueDeclaration,
-    );
-
-    // RETURNS THE RETURN-TYPE
-    const signature: ts.Signature | undefined =
-      props.checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
-    return signature ? signature.getReturnType() : null;
-  };
-
-  export const getFullName = (props: {
-    checker: ts.TypeChecker;
-    type: ts.Type;
-    symbol?: ts.Symbol;
-  }): string => {
-    // PRIMITIVE
-    const symbol =
-      props.symbol ?? props.type.aliasSymbol ?? props.type.getSymbol();
-    if (symbol === undefined) return props.checker.typeToString(props.type);
-
-    // UNION OR INTERSECT
-    if (
-      props.type.aliasSymbol === undefined &&
-      props.type.isUnionOrIntersection()
-    ) {
-      const joiner: string = props.type.isIntersection() ? " & " : " | ";
-      return props.type.types
-        .map((child) =>
-          getFullName({
-            checker: props.checker,
-            type: child,
-          }),
-        )
-        .join(joiner);
-    }
-
-    //----
-    // SPECIALIZATION
-    //----
-    const name: string = get_name(symbol);
-
-    // CHECK GENERIC
-    const generic: readonly ts.Type[] = props.type.aliasSymbol
-      ? (props.type.aliasTypeArguments ?? [])
-      : props.checker.getTypeArguments(props.type as ts.TypeReference);
-    return generic.length
-      ? name === "Promise"
-        ? getFullName({
-            checker: props.checker,
-            type: generic[0]!,
-          })
-        : `${name}<${generic
-            .map((child) =>
-              getFullName({
-                checker: props.checker,
-                type: child,
-              }),
-            )
-            .join(", ")}>`
-      : name;
-  };
-
-  const explore_name = (props: { node: ts.Node; name: string }): string =>
-    ts.isModuleBlock(props.node)
-      ? explore_name({
-          node: props.node.parent.parent,
-          name: `${props.node.parent.name.getFullText().trim()}.${props.name}`,
-        })
-      : props.name;
-
-  const get_name = (symbol: ts.Symbol): string => {
-    const parent = symbol.getDeclarations()?.[0]?.parent;
-    return parent
-      ? explore_name({
-          node: parent,
-          name: symbol.escapedName.toString(),
-        })
-      : "__type";
-  };
-
-  export const keyword = (
-    type:
-      | "void"
-      | "any"
-      | "unknown"
-      | "boolean"
-      | "number"
-      | "bigint"
-      | "string",
-  ) => {
-    return ts.factory.createKeywordTypeNode(
-      type === "void"
-        ? ts.SyntaxKind.VoidKeyword
-        : type === "any"
-          ? ts.SyntaxKind.AnyKeyword
-          : type === "unknown"
-            ? ts.SyntaxKind.UnknownKeyword
-            : type === "boolean"
-              ? ts.SyntaxKind.BooleanKeyword
-              : type === "number"
-                ? ts.SyntaxKind.NumberKeyword
-                : type === "bigint"
-                  ? ts.SyntaxKind.BigIntKeyword
-                  : ts.SyntaxKind.StringKeyword,
-    );
-  };
-}
+import ts from "typescript";
+
+export namespace TypeFactory {
+  export const isFunction = (type: ts.Type): boolean =>
+    getFunction(type) !== null;
+
+  export const getFunction = (type: ts.Type) => {
+    const node = type.symbol?.declarations?.[0];
+    if (node === undefined) return null;
+
+    return ts.isFunctionLike(node)
+      ? node
+      : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
+        ? ts.isFunctionLike(node.initializer)
+          ? node.initializer
+          : null
+        : null;
+  };
+
+  export const getReturnTypeOfClassMethod = (props: {
+    checker: ts.TypeChecker;
+    class: ts.Type;
+    function: string;
+  }): ts.Type | null => {
+    // FIND TO-JSON METHOD
+    const symbol: ts.Symbol | undefined = props.class.getProperty(
+      props.function,
+    );
+    if (!symbol) return null;
+    else if (!symbol.valueDeclaration) return null;
+
+    // GET FUNCTION DECLARATION
+    const functor: ts.Type = props.checker.getTypeOfSymbolAtLocation(
+      symbol,
+      symbol.valueDeclaration,
+    );
+
+    // RETURNS THE RETURN-TYPE
+    const signature: ts.Signature | undefined =
+      props.checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
+    return signature ? signature.getReturnType() : null;
+  };
+
+  export const getFullName = (props: {
+    checker: ts.TypeChecker;
+    type: ts.Type;
+    symbol?: ts.Symbol;
+  }): string => {
+    // PRIMITIVE
+    const symbol =
+      props.symbol ?? props.type.aliasSymbol ?? props.type.getSymbol();
+    if (symbol === undefined) return props.checker.typeToString(props.type);
+
+    // UNION OR INTERSECT
+    if (
+      props.type.aliasSymbol === undefined &&
+      props.type.isUnionOrIntersection()
+    ) {
+      const joiner: string = props.type.isIntersection() ? " & " : " | ";
+      return props.type.types
+        .map((child) =>
+          getFullName({
+            checker: props.checker,
+            type: child,
+          }),
+        )
+        .join(joiner);
+    }
+
+    //----
+    // SPECIALIZATION
+    //----
+    const name: string = get_name(symbol);
+
+    // CHECK GENERIC
+    const generic: readonly ts.Type[] = props.type.aliasSymbol
+      ? (props.type.aliasTypeArguments ?? [])
+      : props.checker.getTypeArguments(props.type as ts.TypeReference);
+    return generic.length
+      ? name === "Promise"
+        ? getFullName({
+            checker: props.checker,
+            type: generic[0]!,
+          })
+        : `${name}<${generic
+            .map((child) =>
+              getFullName({
+                checker: props.checker,
+                type: child,
+              }),
+            )
+            .join(", ")}>`
+      : name;
+  };
+
+  const explore_name = (props: { node: ts.Node; name: string }): string =>
+    ts.isModuleBlock(props.node)
+      ? explore_name({
+          node: props.node.parent.parent,
+          name: `${props.node.parent.name.getFullText().trim()}.${props.name}`,
+        })
+      : props.name;
+
+  const get_name = (symbol: ts.Symbol): string => {
+    const parent = symbol.getDeclarations()?.[0]?.parent;
+    return parent
+      ? explore_name({
+          node: parent,
+          name: symbol.escapedName.toString(),
+        })
+      : "__type";
+  };
+
+  export const keyword = (
+    type:
+      | "void"
+      | "any"
+      | "unknown"
+      | "boolean"
+      | "number"
+      | "bigint"
+      | "string",
+  ) => {
+    return ts.factory.createKeywordTypeNode(
+      type === "void"
+        ? ts.SyntaxKind.VoidKeyword
+        : type === "any"
+          ? ts.SyntaxKind.AnyKeyword
+          : type === "unknown"
+            ? ts.SyntaxKind.UnknownKeyword
+            : type === "boolean"
+              ? ts.SyntaxKind.BooleanKeyword
+              : type === "number"
+                ? ts.SyntaxKind.NumberKeyword
+                : type === "bigint"
+                  ? ts.SyntaxKind.BigIntKeyword
+                  : ts.SyntaxKind.StringKeyword,
+    );
+  };
+}

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

@@ -1,32 +1,32 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_alias = (
-  props: IMetadataIteratorProps,
-): MetadataAlias => {
-  // CHECK EXISTENCE
-  const [alias, newbie, closure] = props.collection.emplaceAlias(
-    props.checker,
-    props.type,
-    props.type.aliasSymbol!,
-  );
-  ArrayUtil.add(alias.nullables, props.metadata.nullable);
-  if (newbie === false) return alias;
-
-  // CONSTRUCT VALUE TYPE
-  const value: Metadata = explore_metadata({
-    ...props,
-    explore: {
-      ...props.explore,
-      escaped: false,
-      aliased: true,
-    },
-  });
-  closure(value);
-  return alias;
-};
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_alias = (
+  props: IMetadataIteratorProps,
+): MetadataAlias => {
+  // CHECK EXISTENCE
+  const [alias, newbie, closure] = props.collection.emplaceAlias(
+    props.checker,
+    props.type,
+    props.type.aliasSymbol!,
+  );
+  ArrayUtil.add(alias.nullables, props.metadata.nullable);
+  if (newbie === false) return alias;
+
+  // CONSTRUCT VALUE TYPE
+  const value: Metadata = explore_metadata({
+    ...props,
+    explore: {
+      ...props.explore,
+      escaped: false,
+      aliased: true,
+    },
+  });
+  closure(value);
+  return alias;
+};

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

@@ -1,39 +1,39 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { explore_metadata } from "./explore_metadata";
-
-interface IProps extends IMetadataIteratorProps {
-  array: ts.Type;
-}
-
-export const emplace_metadata_array_type = (
-  props: IProps,
-): MetadataArrayType => {
-  // CHECK EXISTENCE
-  const [array, newbie, setValue] = props.collection.emplaceArray(
-    props.checker,
-    props.type,
-  );
-  ArrayUtil.add(array.nullables, props.metadata.nullable);
-  if (newbie === false) return array;
-
-  // CONSTRUCT VALUE TYPE
-  const value: Metadata = explore_metadata({
-    ...props,
-    type: props.array.getNumberIndexType()!,
-    explore: {
-      ...props.explore,
-      escaped: false,
-      aliased: false,
-    },
-  });
-  setValue(value);
-
-  return array;
-};
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { explore_metadata } from "./explore_metadata";
+
+interface IProps extends IMetadataIteratorProps {
+  array: ts.Type;
+}
+
+export const emplace_metadata_array_type = (
+  props: IProps,
+): MetadataArrayType => {
+  // CHECK EXISTENCE
+  const [array, newbie, setValue] = props.collection.emplaceArray(
+    props.checker,
+    props.type,
+  );
+  ArrayUtil.add(array.nullables, props.metadata.nullable);
+  if (newbie === false) return array;
+
+  // CONSTRUCT VALUE TYPE
+  const value: Metadata = explore_metadata({
+    ...props,
+    type: props.array.getNumberIndexType()!,
+    explore: {
+      ...props.explore,
+      escaped: false,
+      aliased: false,
+    },
+  });
+  setValue(value);
+
+  return array;
+};

package/src/factories/internal/metadata/emplace_metadata_object.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 { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
 
 import { Writable } from "../../../typings/Writable";
@@ -16,7 +16,7 @@ import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
 
 export const emplace_metadata_object = (
   props: IMetadataIteratorProps,
-): MetadataObject => {
+): MetadataObjectType => {
   // EMPLACE OBJECT
   const [obj, newbie] = props.collection.emplace(props.checker, props.type);
   ArrayUtil.add(