Experiment of samchon/nestia#980: ts.Type de/serialization.

Succeeded to serialized and deserialize `ts.Type` class instnace from the JSON value level.

Also, to accomplish the experiment, refactored `typia` code never to utlize the `ts.Type` methods.

benchmark/package.json

@@ -72,6 +72,6 @@
     "suppress-warnings": "^1.0.2",
     "tstl": "^3.0.0",
     "uuid": "^9.0.1",
-    "typia": "../typia-6.7.2.tgz"
+    "typia": "../typia-6.7.3-dev.20240808.tgz"
   }
 }

errors/package.json

@@ -32,6 +32,6 @@
     "typescript": "^5.3.2"
   },
   "dependencies": {
-    "typia": "../typia-6.7.2.tgz"
+    "typia": "../typia-6.7.3-dev.20240808.tgz"
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "6.7.2",
+  "version": "6.7.3-dev.20240808",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

packages/typescript-json/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-json",
-  "version": "6.7.2",
+  "version": "6.7.3-dev.20240808",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -63,7 +63,7 @@
   },
   "homepage": "https://typia.io",
   "dependencies": {
-    "typia": "6.7.2"
+    "typia": "6.7.3-dev.20240808"
   },
   "peerDependencies": {
     "typescript": ">=4.8.0 <5.6.0"

src/factories/TypeFactory.ts

@@ -1,5 +1,9 @@
 import ts from "typescript";
 
+import { TypePredicator } from "../utils/TypePredicator";
+
+import { Resolved } from "../Resolved";
+
 export namespace TypeFactory {
   export const isFunction = (type: ts.Type): boolean =>
     getFunction(type) !== null;
@@ -22,7 +26,10 @@ export namespace TypeFactory {
     (type: ts.Type) =>
     (name: string): ts.Type | null => {
       // FIND TO-JSON METHOD
-      const symbol: ts.Symbol | undefined = type.getProperty(name);
+      const symbol: ts.Symbol | undefined = checker.getPropertyOfType(
+        type,
+        name,
+      );
       if (!symbol) return null;
       else if (!symbol.valueDeclaration) return null;
 
@@ -44,12 +51,17 @@ export namespace TypeFactory {
     (checker: ts.TypeChecker) =>
     (type: ts.Type, symbol?: ts.Symbol): string => {
       // PRIMITIVE
-      symbol ??= type.aliasSymbol ?? type.getSymbol();
+      symbol ??= type.aliasSymbol ?? type.symbol;
       if (symbol === undefined) return checker.typeToString(type);
 
       // UNION OR INTERSECT
-      if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-        const joiner: string = type.isIntersection() ? " & " : " | ";
+      if (
+        type.aliasSymbol === undefined &&
+        TypePredicator.isUnionOrIntersection(type)
+      ) {
+        const joiner: string = TypePredicator.isIntersection(type)
+          ? " & "
+          : " | ";
         return type.types
           .map((child) => getFullName(checker)(child))
           .join(joiner);
@@ -115,4 +127,64 @@ export namespace TypeFactory {
                   : ts.SyntaxKind.StringKeyword,
     );
   };
+
+  export const clone = (type: ts.Type): Resolved<ts.Type> =>
+    cloneType(type, 0, new Set());
 }
+
+const cloneType = (x: any, depth: number, visited: Set<object>): any => {
+  if (x === undefined || depth > 4) return undefined;
+  else if (typeof x === "object")
+    if (x === null) return null;
+    else if (Array.isArray(x))
+      return x.map((y) => cloneType(y, depth + 1, visited));
+    else {
+      visited.add(x);
+      const entries = (() => {
+        try {
+          return Object.entries(x);
+        } catch {
+          return undefined;
+        }
+      })();
+      if (entries === undefined) return undefined;
+      return Object.fromEntries(
+        entries
+          .filter(
+            ([k, y]) =>
+              k !== "parent" &&
+              typeof y !== "function" &&
+              !(typeof y === "object" && y !== null && visited.has(y) === true),
+          )
+          .map(([k, y]) => {
+            // if (typeof y === "object" && y !== null) console.log(k, get_uid(y));
+            return [k, cloneType(y, depth + 1, visited)];
+          }),
+      );
+    }
+  return x;
+};
+
+// function get_uid(obj: object | null | undefined): number {
+//   // NO UID EXISTS, THEN ISSUE ONE.
+//   if (obj instanceof Object) {
+//     if (obj.hasOwnProperty("__get_m_iUID") === false) {
+//       const uid: number = ++__s_iUID;
+//       Object.defineProperty(obj, "__get_m_iUID", {
+//         value: function (): number {
+//           return uid;
+//         },
+//       });
+//     }
+
+//     // RETURNS
+//     return (obj as IObject).__get_m_iUID();
+//   } else if (obj === undefined) return -1;
+//   // is null
+//   else return 0;
+// }
+
+// interface IObject {
+//   readonly __get_m_iUID: () => number;
+// }
+// let __s_iUID: number = 0;

src/factories/internal/metadata/emplace_metadata_array_type.ts

@@ -31,7 +31,7 @@ export const emplace_metadata_array_type =
     // CONSTRUCT VALUE TYPE
     const value: Metadata = explore_metadata(checker)(options)(collection)(
       errors,
-    )(arrayType.getNumberIndexType()!, {
+    )(checker.getIndexTypeOfType(arrayType, ts.IndexKind.Number)!, {
       ...explore,
       escaped: false,
       aliased: false,

src/factories/internal/metadata/emplace_metadata_object.ts

@@ -7,6 +7,7 @@ import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
 import { Writable } from "../../../typings/Writable";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { CommentFactory } from "../../CommentFactory";
 import { MetadataCollection } from "../../MetadataCollection";
@@ -28,7 +29,7 @@ export const emplace_metadata_object =
     if (newbie === false) return obj;
 
     // PREPARE ASSETS
-    const isClass: boolean = parent.isClass();
+    const isClass: boolean = TypePredicator.isClass(parent);
     const pred: (node: ts.Declaration) => boolean = isClass
       ? (node) => {
           const kind: ts.SyntaxKind | undefined = node
@@ -71,7 +72,9 @@ export const emplace_metadata_object =
     //----
     // REGULAR PROPERTIES
     //----
-    for (const prop of parent.getApparentProperties()) {
+    for (const prop of checker.getPropertiesOfType(
+      checker.getApparentType(parent),
+    )) {
       // CHECK INTERNAL TAG
       if (
         (prop.getJsDocTags(checker) ?? []).find(
@@ -170,7 +173,7 @@ const isProperty = (node: ts.Declaration) =>
   ts.isTypeLiteralNode(node);
 
 const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
-  if (type.isUnionOrIntersection())
+  if (TypePredicator.isUnionOrIntersection(type))
     type.types.forEach((child) => iterate_optional_coalesce(meta, child));
   else iterate_metadata_coalesce(meta, type);
 };

src/factories/internal/metadata/iterate_metadata.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
@@ -26,7 +28,7 @@ export const iterate_metadata =
   (collection: MetadataCollection) =>
   (errors: MetadataFactory.IError[]) =>
   (meta: Metadata, type: ts.Type, explore: MetadataFactory.IExplore): void => {
-    if (type.isTypeParameter() === true) {
+    if (TypePredicator.isTypeParameter(type) === true) {
       errors.push({
         name: TypeFactory.getFullName(checker)(type),
         explore: { ...explore },

src/factories/internal/metadata/iterate_metadata_array.ts

@@ -5,6 +5,7 @@ import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -49,7 +50,7 @@ const find_array_extended =
 
     memory.set(type, null);
     const res: ts.Type | null = (() => {
-      if (type.isClassOrInterface() === false) return null;
+      if (TypePredicator.isInterfaceOrClass(type) === false) return null;
       for (const t of type.resolvedBaseTypes ?? [])
         if (checker.isArrayType(t)) return t;
         else {

src/factories/internal/metadata/iterate_metadata_atomic.ts

@@ -7,7 +7,7 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 const same = (type: ts.Type | null) => {
   if (type === null) return () => false;
-  return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+  return (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
 };
 
 export const iterate_metadata_atomic = (

src/factories/internal/metadata/iterate_metadata_coalesce.ts

@@ -10,7 +10,7 @@ export const iterate_metadata_coalesce = (
   meta: Metadata,
   type: ts.Type,
 ): boolean => {
-  const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+  const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
   if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
     Writable(meta).any = true;
     return true;

src/factories/internal/metadata/iterate_metadata_constant.ts

@@ -5,6 +5,7 @@ import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
 import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { CommentFactory } from "../../CommentFactory";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -15,7 +16,7 @@ export const iterate_metadata_constant =
   (meta: Metadata, type: ts.Type): boolean => {
     if (!options.constant) return false;
 
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
     const comment = () => {
       if (!filter(ts.TypeFlags.EnumLiteral)) return {};
       return {
@@ -25,7 +26,7 @@ export const iterate_metadata_constant =
           : undefined,
       };
     };
-    if (type.isLiteral()) {
+    if (TypePredicator.isLiteral(type)) {
       const value: string | number | bigint =
         typeof type.value === "object"
           ? BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`)

src/factories/internal/metadata/iterate_metadata_intersection.ts

@@ -8,6 +8,7 @@ import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstan
 import { MetadataTemplate } from "../../../schemas/metadata/MetadataTemplate";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -26,12 +27,12 @@ export const iterate_metadata_intersection =
     type: ts.Type,
     explore: MetadataFactory.IExplore,
   ): boolean => {
-    if (!type.isIntersection()) return false;
+    if (TypePredicator.isIntersection(type) === false) return false;
     if (
       // ONLY OBJECT TYPED INTERSECTION
       type.types.every(
         (child) =>
-          (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
+          (child.flags & ts.TypeFlags.Object) !== 0 &&
           !checker.isArrayType(child) &&
           !checker.isTupleType(child),
       )

src/factories/internal/metadata/iterate_metadata_map.ts

@@ -21,7 +21,7 @@ export const iterate_metadata_map =
   ): boolean => {
     type = checker.getApparentType(type);
 
-    const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+    const name = TypeFactory.getFullName(checker)(type, type.symbol);
     const generic = type.aliasSymbol
       ? type.aliasTypeArguments
       : checker.getTypeArguments(type as ts.TypeReference);

src/factories/internal/metadata/iterate_metadata_native.ts

@@ -10,10 +10,7 @@ export const iterate_metadata_native =
   (checker: ts.TypeChecker) =>
   (meta: Metadata, type: ts.Type): boolean => {
     const validator = validate(checker)(type);
-    const name: string = TypeFactory.getFullName(checker)(
-      type,
-      type.getSymbol(),
-    );
+    const name: string = TypeFactory.getFullName(checker)(type, type.symbol);
 
     const simple = SIMPLES.get(name);
     if (simple && validator(simple)) {

src/factories/internal/metadata/iterate_metadata_object.ts

@@ -4,6 +4,7 @@ import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -16,10 +17,10 @@ export const iterate_metadata_object =
   (errors: MetadataFactory.IError[]) =>
   (meta: Metadata, type: ts.Type, ensure: boolean = false): boolean => {
     if (ensure === false) {
-      const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+      const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
       if (
         !filter(ts.TypeFlags.Object) &&
-        !type.isIntersection() &&
+        !TypePredicator.isIntersection(type) &&
         (type as any).intrinsicName !== "object"
       )
         return false;

src/factories/internal/metadata/iterate_metadata_set.ts

@@ -21,7 +21,7 @@ export const iterate_metadata_set =
   ): boolean => {
     type = checker.getApparentType(type);
 
-    const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+    const name = TypeFactory.getFullName(checker)(type, type.symbol);
     const generic = type.aliasSymbol
       ? type.aliasTypeArguments
       : checker.getTypeArguments(type as ts.TypeReference);

src/factories/internal/metadata/iterate_metadata_template.ts

@@ -18,7 +18,7 @@ export const iterate_metadata_template =
     type: ts.Type,
     explore: MetadataFactory.IExplore,
   ): boolean => {
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
     if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
 
     const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;

src/factories/internal/metadata/iterate_metadata_union.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { iterate_metadata } from "./iterate_metadata";
@@ -16,7 +18,7 @@ export const iterate_metadata_union =
     type: ts.Type,
     explore: MetadataFactory.IExplore,
   ): boolean => {
-    if (!type.isUnion()) return false;
+    if (TypePredicator.isUnion(type) === false) return false;
     type.types.forEach((t) =>
       iterate_metadata(checker)(options)(collection)(errors)(meta, t, {
         ...explore,

src/transformers/features/CreateRandomTransformer.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
+import { TypePredicator } from "../../utils/TypePredicator";
+
 import { IProject } from "../IProject";
 import { TransformerError } from "../TransformerError";
 
@@ -21,7 +23,7 @@ export namespace CreateRandomTransformer {
       const node: ts.TypeNode = expression.typeArguments[0];
       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-      if (type.isTypeParameter())
+      if (TypePredicator.isTypeParameter(type))
         throw new TransformerError({
           code: "typia.createRandom",
           message: "non-specified generic argument.",