@nestia/sdk 11.2.0 → 12.0.0-dev.20260520.1

package/src/generates/internal/SdkTypeProgrammer.ts

@@ -1,18 +1,7 @@
-import {
-  ExpressionFactory,
-  MetadataAliasType,
-  MetadataArray,
-  MetadataAtomic,
-  MetadataConstantValue,
-  MetadataEscaped,
-  MetadataObjectType,
-  MetadataProperty,
-  MetadataSchema,
-  MetadataTuple,
-  TypeFactory,
-} from "@typia/core";
+import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { ExpressionFactory, TypeFactory } from "@nestia/factory";
+import { MetadataAliasType, MetadataArray, MetadataAtomic, MetadataConstantValue, MetadataEscaped, MetadataObjectType, MetadataProperty, MetadataSchema, MetadataTuple, isSoleLiteralOf, sizeOf } from "../../internal/legacy";
 import { NamingConvention } from "@typia/utils";
-import ts from "typescript";
 import { IJsDocTagInfo, IMetadataTypeTag } from "typia";
 
 import { INestiaProject } from "../../structures/INestiaProject";
@@ -27,13 +16,13 @@ export namespace SdkTypeProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (meta: MetadataSchema, parentEscaped: boolean = false): ts.TypeNode => {
-      const union: ts.TypeNode[] = [];
+    (meta: MetadataSchema, parentEscaped: boolean = false): Node => {
+      const union: Node[] = [];
 
       // COALESCES
       if (meta.any) union.push(TypeFactory.keyword("any"));
       if (meta.nullable) union.push(writeNode("null"));
-      if (meta.isRequired() === false) union.push(writeNode("undefined"));
+      if (meta.required === false) union.push(writeNode("undefined"));
       if (parentEscaped === false && meta.escaped)
         union.push(write_escaped(project)(importer)(meta.escaped));
 
@@ -46,43 +35,45 @@ export namespace SdkTypeProgrammer {
 
       // OBJECT TYPES
       for (const tuple of meta.tuples)
-        union.push(write_tuple(project)(importer)(tuple));
+        union.push(write_tuple(project)(importer)(tuple as MetadataTuple));
       for (const array of meta.arrays)
-        union.push(write_array(project)(importer)(array));
-      for (const object of meta.objects)
+        union.push(write_array(project)(importer)(array as MetadataArray));
+      for (const object of meta.objects) {
+        const target = object.type as MetadataObjectType;
         if (
-          object.type.name === "object" ||
-          object.type.name === "__type" ||
-          object.type.name.startsWith("__type.") ||
-          object.type.name === "__object" ||
-          object.type.name.startsWith("__object.")
+          target.name === "object" ||
+          target.name === "__type" ||
+          target.name.startsWith("__type.") ||
+          target.name === "__object" ||
+          target.name.startsWith("__object.")
         )
-          union.push(write_object(project)(importer)(object.type));
-        else union.push(writeAlias(project)(importer)(object.type));
+          union.push(write_object(project)(importer)(target));
+        else union.push(writeAlias(project)(importer)(target));
+      }
       for (const alias of meta.aliases)
-        union.push(writeAlias(project)(importer)(alias.type));
+        union.push(writeAlias(project)(importer)(alias.type as MetadataAliasType));
       for (const native of meta.natives)
         if (native.name === "Blob" || native.name === "File")
           union.push(write_native(native.name));
 
       return union.length === 1
         ? union[0]!
-        : ts.factory.createUnionTypeNode(union);
+        : TypeScriptFactory.createUnionTypeNode(union);
     };
 
   export const write_object =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (object: MetadataObjectType): ts.TypeNode => {
-      const regular = object.properties.filter((p) => p.key.isSoleLiteral());
-      const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
+    (object: MetadataObjectType): Node => {
+      const regular = object.properties.filter((p) => isSoleLiteralOf(p.key));
+      const dynamic = object.properties.filter((p) => !isSoleLiteralOf(p.key));
       return regular.length && dynamic.length
-        ? ts.factory.createIntersectionTypeNode([
+        ? TypeScriptFactory.createIntersectionTypeNode([
             write_regular_property(project)(importer)(regular),
             ...dynamic.map(write_dynamic_property(project)(importer)),
           ])
         : dynamic.length
-          ? ts.factory.createIntersectionTypeNode(
+          ? TypeScriptFactory.createIntersectionTypeNode(
               dynamic.map(write_dynamic_property(project)(importer)),
             )
           : write_regular_property(project)(importer)(regular);
@@ -91,13 +82,13 @@ export namespace SdkTypeProgrammer {
   const write_escaped =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (meta: MetadataEscaped): ts.TypeNode => {
+    (meta: MetadataEscaped): Node => {
       if (
-        meta.original.size() === 1 &&
+        sizeOf(meta.original) === 1 &&
         meta.original.natives.length === 1 &&
         meta.original.natives[0]!.name === "Date"
       )
-        return ts.factory.createIntersectionTypeNode([
+        return TypeScriptFactory.createIntersectionTypeNode([
           TypeFactory.keyword("string"),
           SdkTypeTagProgrammer.write(importer, "string", {
             name: "Format",
@@ -112,48 +103,50 @@ export namespace SdkTypeProgrammer {
   ----------------------------------------------------------- */
   const write_constant = (value: MetadataConstantValue) => {
     if (typeof value.value === "boolean")
-      return ts.factory.createLiteralTypeNode(
-        value ? ts.factory.createTrue() : ts.factory.createFalse(),
+      return TypeScriptFactory.createLiteralTypeNode(
+        value.value
+          ? TypeScriptFactory.createTrue()
+          : TypeScriptFactory.createFalse(),
       );
     else if (typeof value.value === "bigint")
-      return ts.factory.createLiteralTypeNode(
+      return TypeScriptFactory.createLiteralTypeNode(
         value.value < BigInt(0)
-          ? ts.factory.createPrefixUnaryExpression(
-              ts.SyntaxKind.MinusToken,
-              ts.factory.createBigIntLiteral((-value).toString()),
+          ? TypeScriptFactory.createPrefixUnaryExpression(
+              SyntaxKind.MinusToken,
+              TypeScriptFactory.createBigIntLiteral((-value.value).toString()),
             )
-          : ts.factory.createBigIntLiteral(value.toString()),
+          : TypeScriptFactory.createBigIntLiteral(value.value.toString()),
       );
     else if (typeof value.value === "number")
-      return ts.factory.createLiteralTypeNode(
+      return TypeScriptFactory.createLiteralTypeNode(
         ExpressionFactory.number(value.value),
       );
-    return ts.factory.createLiteralTypeNode(
-      ts.factory.createStringLiteral(value.value as string),
+    return TypeScriptFactory.createLiteralTypeNode(
+      TypeScriptFactory.createStringLiteral(value.value as string),
     );
   };
 
   const write_template =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (meta: MetadataSchema[]): ts.TypeNode => {
-      const head: boolean = meta[0]!.isSoleLiteral();
-      const spans: [ts.TypeNode | null, string | null][] = [];
+    (meta: MetadataSchema[]): Node => {
+      const head: boolean = isSoleLiteralOf(meta[0]!);
+      const spans: [Node | null, string | null][] = [];
       for (const elem of meta.slice(head ? 1 : 0)) {
         const last =
           spans.at(-1) ??
           (() => {
-            const tuple = [null!, null!] as [ts.TypeNode | null, string | null];
+            const tuple = [null!, null!] as [Node | null, string | null];
             spans.push(tuple);
             return tuple;
           })();
-        if (elem.isSoleLiteral())
+        if (isSoleLiteralOf(elem))
           if (last[1] === null)
             last[1] = String(elem.constants[0]!.values[0]!.value);
           else
             spans.push([
-              ts.factory.createLiteralTypeNode(
-                ts.factory.createStringLiteral(
+              TypeScriptFactory.createLiteralTypeNode(
+                TypeScriptFactory.createStringLiteral(
                   String(elem.constants[0]!.values[0]!.value),
                 ),
               ),
@@ -162,18 +155,18 @@ export namespace SdkTypeProgrammer {
         else if (last[0] === null) last[0] = write(project)(importer)(elem);
         else spans.push([write(project)(importer)(elem), null]);
       }
-      return ts.factory.createTemplateLiteralType(
-        ts.factory.createTemplateHead(
+      return TypeScriptFactory.createTemplateLiteralType(
+        TypeScriptFactory.createTemplateHead(
           head ? (meta[0]!.constants[0]!.values[0]!.value as string) : "",
         ),
         spans
           .filter(([node]) => node !== null)
           .map(([node, str], i, array) =>
-            ts.factory.createTemplateLiteralTypeSpan(
+            TypeScriptFactory.createTemplateLiteralTypeSpan(
               node!,
               (i !== array.length - 1
-                ? ts.factory.createTemplateMiddle
-                : ts.factory.createTemplateTail)(str ?? ""),
+                ? TypeScriptFactory.createTemplateMiddle
+                : TypeScriptFactory.createTemplateTail)(str ?? ""),
             ),
           ),
       );
@@ -181,17 +174,17 @@ export namespace SdkTypeProgrammer {
 
   const write_atomic =
     (importer: ImportDictionary) =>
-    (meta: MetadataAtomic): ts.TypeNode =>
+    (meta: MetadataAtomic): Node =>
       write_type_tag_matrix(importer)(
         meta.type as "boolean" | "bigint" | "number" | "string",
-        ts.factory.createKeywordTypeNode(
+        TypeScriptFactory.createKeywordTypeNode(
           meta.type === "boolean"
-            ? ts.SyntaxKind.BooleanKeyword
+            ? SyntaxKind.BooleanKeyword
             : meta.type === "bigint"
-              ? ts.SyntaxKind.BigIntKeyword
+              ? SyntaxKind.BigIntKeyword
               : meta.type === "number"
-                ? ts.SyntaxKind.NumberKeyword
-                : ts.SyntaxKind.StringKeyword,
+                ? SyntaxKind.NumberKeyword
+                : SyntaxKind.StringKeyword,
         ),
         meta.tags,
       );
@@ -202,11 +195,11 @@ export namespace SdkTypeProgrammer {
   const write_array =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (meta: MetadataArray): ts.TypeNode =>
+    (meta: MetadataArray): Node =>
       write_type_tag_matrix(importer)(
         "array",
-        ts.factory.createArrayTypeNode(
-          write(project)(importer)(meta.type.value),
+        TypeScriptFactory.createArrayTypeNode(
+          write(project)(importer)(meta.type!.value),
         ),
         meta.tags,
       );
@@ -214,17 +207,17 @@ export namespace SdkTypeProgrammer {
   const write_tuple =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (meta: MetadataTuple): ts.TypeNode =>
-      ts.factory.createTupleTypeNode(
-        meta.type.elements.map((elem) =>
+    (meta: MetadataTuple): Node =>
+      TypeScriptFactory.createTupleTypeNode(
+        meta.type!.elements.map((elem) =>
           elem.rest
-            ? ts.factory.createRestTypeNode(
-                ts.factory.createArrayTypeNode(
+            ? TypeScriptFactory.createRestTypeNode(
+                TypeScriptFactory.createArrayTypeNode(
                   write(project)(importer)(elem.rest),
                 ),
               )
             : elem.optional
-              ? ts.factory.createOptionalTypeNode(
+              ? TypeScriptFactory.createOptionalTypeNode(
                   write(project)(importer)(elem),
                 )
               : write(project)(importer)(elem),
@@ -234,34 +227,34 @@ export namespace SdkTypeProgrammer {
   const write_regular_property =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (properties: MetadataProperty[]): ts.TypeLiteralNode =>
-      ts.factory.createTypeLiteralNode(
+    (properties: MetadataProperty[]): Node =>
+      TypeScriptFactory.createTypeLiteralNode(
         properties
           .map((p) => {
             const description: string = writeComment(p.value.atomics)(
               p.description,
               p.jsDocTags,
             );
-            const signature: ts.PropertySignature =
-              ts.factory.createPropertySignature(
+            const signature: Node =
+              TypeScriptFactory.createPropertySignature(
                 undefined,
                 NamingConvention.variable(
                   String(p.key.constants[0]!.values[0]!.value),
                 )
-                  ? ts.factory.createIdentifier(
+                  ? TypeScriptFactory.createIdentifier(
                       String(p.key.constants[0]!.values[0]!.value),
                     )
-                  : ts.factory.createStringLiteral(
+                  : TypeScriptFactory.createStringLiteral(
                       String(p.key.constants[0]!.values[0]!.value),
                     ),
-                p.value.isRequired() === false
-                  ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                p.value.required === false
+                  ? TypeScriptFactory.createToken(SyntaxKind.QuestionToken)
                   : undefined,
                 SdkTypeProgrammer.write(project)(importer)(p.value),
               );
             return !!description.length
               ? [
-                  ts.factory.createIdentifier("\n") as any,
+                  TypeScriptFactory.createIdentifier("\n") as any,
                   FilePrinter.description(signature, description),
                 ]
               : signature;
@@ -272,16 +265,16 @@ export namespace SdkTypeProgrammer {
   const write_dynamic_property =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (property: MetadataProperty): ts.TypeLiteralNode =>
-      ts.factory.createTypeLiteralNode([
+    (property: MetadataProperty): Node =>
+      TypeScriptFactory.createTypeLiteralNode([
         FilePrinter.description(
-          ts.factory.createIndexSignature(
+          TypeScriptFactory.createIndexSignature(
             undefined,
             [
-              ts.factory.createParameterDeclaration(
+              TypeScriptFactory.createParameterDeclaration(
                 undefined,
                 undefined,
-                ts.factory.createIdentifier("key"),
+                TypeScriptFactory.createIdentifier("key"),
                 undefined,
                 SdkTypeProgrammer.write(project)(importer)(property.key),
               ),
@@ -298,13 +291,13 @@ export namespace SdkTypeProgrammer {
   const writeAlias =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (meta: MetadataAliasType | MetadataObjectType): ts.TypeNode => {
+    (meta: MetadataAliasType | MetadataObjectType): Node => {
       importInternalFile(project)(importer)(meta.name);
-      return ts.factory.createTypeReferenceNode(meta.name);
+      return TypeScriptFactory.createTypeReferenceNode(meta.name);
     };
 
-  const write_native = (name: string): ts.TypeNode =>
-    ts.factory.createTypeReferenceNode(name);
+  const write_native = (name: string): Node =>
+    TypeScriptFactory.createTypeReferenceNode(name);
 
   /* -----------------------------------------------------------
     MISCELLANEOUS
@@ -313,25 +306,25 @@ export namespace SdkTypeProgrammer {
     (importer: ImportDictionary) =>
     (
       from: "array" | "boolean" | "number" | "bigint" | "string" | "object",
-      base: ts.TypeNode,
+      base: Node,
       matrix: IMetadataTypeTag[][],
-    ): ts.TypeNode => {
+    ): Node => {
       matrix = matrix.filter((row) => row.length !== 0);
       if (matrix.length === 0) return base;
       else if (matrix.length === 1)
-        return ts.factory.createIntersectionTypeNode([
+        return TypeScriptFactory.createIntersectionTypeNode([
           base,
           ...matrix[0]!.map((tag) =>
             SdkTypeTagProgrammer.write(importer, from, tag),
           ),
         ]);
-      return ts.factory.createIntersectionTypeNode([
+      return TypeScriptFactory.createIntersectionTypeNode([
         base,
-        ts.factory.createUnionTypeNode(
+        TypeScriptFactory.createUnionTypeNode(
           matrix.map((row) =>
             row.length === 1
               ? SdkTypeTagProgrammer.write(importer, from, row[0]!)
-              : ts.factory.createIntersectionTypeNode(
+              : TypeScriptFactory.createIntersectionTypeNode(
                   row.map((tag) =>
                     SdkTypeTagProgrammer.write(importer, from, tag),
                   ),
@@ -342,7 +335,8 @@ export namespace SdkTypeProgrammer {
     };
 }
 
-const writeNode = (text: string) => ts.factory.createTypeReferenceNode(text);
+const writeNode = (text: string) =>
+  TypeScriptFactory.createTypeReferenceNode(text);
 const writeComment =
   (atomics: MetadataAtomic[]) =>
   (description: string | null, jsDocTags: IJsDocTagInfo[]): string => {

package/src/generates/internal/SdkTypeTagProgrammer.ts

@@ -1,6 +1,6 @@
-import { LiteralFactory } from "@typia/core";
+import { TypeScriptFactory } from "@nestia/factory";
+import { LiteralFactory } from "@nestia/factory";
 import { IMetadataTypeTag } from "@typia/interface";
-import ts from "typescript";
 
 import { ImportDictionary } from "./ImportDictionary";
 
@@ -12,9 +12,9 @@ export namespace SdkTypeTagProgrammer {
   ) => {
     const name: string = tag.name.split("<")[0]!;
     if (PREDEFINED[from]?.has(name) === true)
-      return ts.factory.createTypeReferenceNode(
-        ts.factory.createQualifiedName(
-          ts.factory.createIdentifier(
+      return TypeScriptFactory.createTypeReferenceNode(
+        TypeScriptFactory.createQualifiedName(
+          TypeScriptFactory.createIdentifier(
             importer.external({
               declaration: true,
               file: `typia`,
@@ -22,17 +22,17 @@ export namespace SdkTypeTagProgrammer {
               name: "tags",
             }),
           ),
-          ts.factory.createIdentifier(name),
+          TypeScriptFactory.createIdentifier(name),
         ),
         [
-          ts.factory.createLiteralTypeNode(
+          TypeScriptFactory.createLiteralTypeNode(
             LiteralFactory.write(tag.value) as any,
           ),
         ],
       );
-    return ts.factory.createTypeReferenceNode(
-      ts.factory.createQualifiedName(
-        ts.factory.createIdentifier(
+    return TypeScriptFactory.createTypeReferenceNode(
+      TypeScriptFactory.createQualifiedName(
+        TypeScriptFactory.createIdentifier(
           importer.external({
             declaration: true,
             file: `typia`,
@@ -40,10 +40,10 @@ export namespace SdkTypeTagProgrammer {
             name: "tags",
           }),
         ),
-        ts.factory.createIdentifier("TagBase"),
+        TypeScriptFactory.createIdentifier("TagBase"),
       ),
       [
-        ts.factory.createLiteralTypeNode(
+        TypeScriptFactory.createLiteralTypeNode(
           LiteralFactory.write({
             target: from,
             kind: tag.kind,