typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

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

@@ -1,7 +1,9 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { Writable } from "../../../typings/Writable";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
@@ -11,11 +13,12 @@ import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_tuple =
-    (checker: ts.TypeChecker) =>
+    ({ tsc, checker }: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.TupleType): boolean => {
-        if (!(checker as any).isTupleType(type)) return false;
+    (meta: Metadata) =>
+    (type: ts.TupleType): boolean => {
+        if (!checker.isTupleType(type)) return false;
 
         const elementFlags: readonly ts.ElementFlags[] =
             type.elementFlags ??
@@ -25,17 +28,17 @@ export const iterate_metadata_tuple =
         const children: Metadata[] = checker
             .getTypeArguments(type as ts.TypeReference)
             .map((elem, i) => {
-                const child: Metadata = explore_metadata(checker)(options)(
-                    collection,
-                )(elem, false);
+                const child: Metadata = explore_metadata({ tsc, checker })(
+                    options,
+                )(collection)(false)(elem);
 
                 // CHECK OPTIONAL
                 const flag: ts.ElementFlags | undefined = elementFlags[i];
-                if (flag === ts.ElementFlags.Optional)
+                if (flag === tsc.ElementFlags.Optional)
                     Writable(child).optional = true;
 
                 // REST TYPE
-                if (flag !== ts.ElementFlags.Rest) return child;
+                if (flag !== tsc.ElementFlags.Rest) return child;
                 const wrapper: Metadata = Metadata.initialize();
                 Writable(wrapper).rest = child;
                 return wrapper;

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

@@ -1,36 +1,42 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { Writable } from "../../../typings/Writable";
 
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const iterate_metadata_union =
-    (checker: ts.TypeChecker) =>
+    (p: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
-        if (!type.isUnion()) return false;
+    (parentResolved: boolean) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        if (!TsTypeUtil.isUnion(p.tsc)(type)) return false;
         else if (options.resolve === false || parentResolved === true) {
             type.types.forEach((t) =>
-                iterate_metadata(checker)(options)(collection)(meta, t, false),
+                iterate_metadata(p)(options)(collection)(false)(meta)(t),
             );
             return true;
         }
 
         const filter = (flag: ts.TypeFlags, t: ts.Type) =>
-            (t.getFlags() & flag) !== 0;
+            (t.flags & flag) !== 0;
         const normals: ts.Type[] = [];
         const toJsons: ts.Type[] = [];
 
         for (const individual of type.types) {
-            if (filter(ts.TypeFlags.Object, individual)) {
+            if (filter(p.tsc.TypeFlags.Object, individual)) {
                 const resolved: ts.Type | null =
-                    TypeFactory.resolve(checker)(individual);
+                    TypeFactory.resolve(p)(individual);
                 if (resolved !== null) toJsons.push(resolved);
                 else normals.push(individual);
             } else normals.push(individual);
@@ -39,11 +45,7 @@ export const iterate_metadata_union =
             Writable(meta).resolved = (() => {
                 const union: Metadata = Metadata.initialize();
                 toJsons.forEach((t) =>
-                    iterate_metadata(checker)(options)(collection)(
-                        meta,
-                        t,
-                        true,
-                    ),
+                    iterate_metadata(p)(options)(collection)(true)(meta)(t),
                 );
                 if (union.objects.length > 1)
                     union.union_index = collection.getUnionIndex(union);
@@ -51,7 +53,7 @@ export const iterate_metadata_union =
             })();
         }
         normals.forEach((t) =>
-            iterate_metadata(checker)(options)(collection)(meta, t, false),
+            iterate_metadata(p)(options)(collection)(false)(meta)(t),
         );
         return true;
     };

package/src/metadata/IMetadataTag.ts

@@ -1,6 +1,6 @@
 export type IMetadataTag =
     // NUMBER
-    | IMetadataTag.INumberType
+    | IMetadataTag.IType
     | IMetadataTag.IMinimum
     | IMetadataTag.IMaximum
     | IMetadataTag.IExclusiveMinimum
@@ -22,17 +22,9 @@ export namespace IMetadataTag {
     /* -----------------------------------------------------------
         NUMBER
     ----------------------------------------------------------- */
-    export interface INumberType {
+    export interface IType {
         kind: "type";
-        value:
-            | "int"
-            | "uint"
-            | "int32"
-            | "uint32"
-            | "int64"
-            | "uint64"
-            | "float"
-            | "double";
+        value: "int" | "uint";
     }
 
     export interface IMinimum {

package/src/metadata/Metadata.ts

@@ -210,7 +210,6 @@ export class Metadata {
     public empty(): boolean {
         return this.bucket() === 0 || this.size() === 0;
     }
-
     public size(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -229,7 +228,6 @@ export class Metadata {
             this.maps.length
         );
     }
-
     public bucket(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -246,7 +244,6 @@ export class Metadata {
             (this.maps.length ? 1 : 0)
         );
     }
-
     public isConstant(): boolean {
         return this.bucket() === (this.constants.length ? 1 : 0);
     }
@@ -517,8 +514,7 @@ const getName = (metadata: Metadata): string => {
         elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
 
     // ARRAY
-    if (metadata.rest !== null)
-        elements.push(`Rest<${metadata.rest.getName()}>`);
+    if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
     for (const tuple of metadata.tuples)
         elements.push(`[${tuple.map((elem) => elem.getName()).join(", ")}]`);
     for (const array of metadata.arrays)

package/src/module.ts

@@ -26,7 +26,6 @@ export * from "./TypeGuardError";
     SINGLE FUNCTIONS
         - BASIC VALIDATORS
         - STRICT VALIDATORS
-        - PROTOCOL BUFFER FUNCTIONS
         - JSON FUNCTIONS
         - MISCELLANEOUS
 ==============================================================
@@ -467,16 +466,6 @@ export const customValidators: CustomValidatorMap = {
     erase: (name) => (type) => $dictionary.get(name)?.delete(type) ?? false,
 };
 
-/* -----------------------------------------------------------
-    PROTOCOL BUFFER FUNCTIONS
------------------------------------------------------------ */
-export function message(): never;
-export function message<T>(): string;
-
-export function message(): string {
-    halt("message");
-}
-
 /* -----------------------------------------------------------
     JSON FUNCTIONS
 ----------------------------------------------------------- */
@@ -499,7 +488,6 @@ export function message(): string {
  *
  * @template Types Tuple of target types
  * @template Purpose Purpose of the JSON schema`
- * @template Prefix Prefix of the JSON components referenced by `$ref` tag
  * @return JSON schema application
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -523,17 +511,13 @@ export function application(): never;
  *
  * @template Types Tuple of target types
  * @template Purpose Purpose of the JSON schema
- * @template Prefix Prefix of the JSON components referenced by `$ref` tag
  * @return JSON schema application
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
 export function application<
     Types extends unknown[],
-    Purpose extends "swagger" | "ajv" = "swagger",
-    Prefix extends string = Purpose extends "swagger"
-        ? "#/components/schemas"
-        : "components#/schemas",
+    Purpose extends "ajv" | "swagger" = "swagger",
 >(): IJsonApplication;
 
 /**

package/src/programmers/ApplicationProgrammer.ts

@@ -6,12 +6,8 @@ import { IJsonSchema } from "../schemas/IJsonSchema";
 import { application_schema } from "./internal/application_schema";
 
 export namespace ApplicationProgrammer {
-    export const AJV_PREFIX = "components#/schemas";
-    export const SWAGGER_PREFIX = "#/components/schemas";
-
     export interface IOptions {
-        purpose: "swagger" | "ajv";
-        prefix: string;
+        purpose: "ajv" | "swagger";
     }
 
     /**
@@ -22,21 +18,10 @@ export namespace ApplicationProgrammer {
             const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
             return {
                 purpose,
-                prefix:
-                    options?.prefix ||
-                    (purpose === "swagger" ? SWAGGER_PREFIX : AJV_PREFIX),
             };
         };
     }
 
-    /**
-     * @deprecated Use `write()` function instead
-     */
-    export const generate = (
-        metadatas: Array<Metadata>,
-        options?: Partial<IOptions>,
-    ): IJsonApplication => write(options)(metadatas);
-
     export const write =
         (options?: Partial<IOptions>) =>
         (metadatas: Array<Metadata>): IJsonApplication => {
@@ -57,6 +42,7 @@ export namespace ApplicationProgrammer {
                 }),
                 components,
                 ...fullOptions,
+                prefix: "#/components/schemas",
             };
         };
 }

package/src/programmers/AssertCloneProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
@@ -10,69 +10,58 @@ import { AssertProgrammer } from "./AssertProgrammer";
 import { CloneProgrammer } from "./CloneProgrammer";
 
 export namespace AssertCloneProgrammer {
-    /**
-     * @deprecated Use `write()` function instead
-     */
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            write(project)(modulo)(type, name);
-
     export const write =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+            p.tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(
+                    IdentifierFactory.parameter(p.tsc)(
                         "input",
-                        TypeFactory.keyword("any"),
+                        TypeFactory.keyword(p.tsc)("any"),
                     ),
                 ],
-                ts.factory.createTypeReferenceNode(
+                p.tsc.factory.createTypeReferenceNode(
                     `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
+                        name ?? TypeFactory.getFullName(p)(type)
                     }>`,
                 ),
                 undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
                         "assert",
-                        AssertProgrammer.write(project)(modulo)(false)(
-                            type,
-                            name,
-                        ),
+                        AssertProgrammer.write(p)(modulo)(false)(type, name),
                     ),
-                    StatementFactory.constant(
+                    StatementFactory.constant(p.tsc)(
                         "clone",
                         CloneProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(type, name),
                     ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("assert"),
+                    p.tsc.factory.createExpressionStatement(
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("assert"),
                             undefined,
-                            [ts.factory.createIdentifier("input")],
+                            [p.tsc.factory.createIdentifier("input")],
                         ),
                     ),
-                    StatementFactory.constant(
+                    StatementFactory.constant(p.tsc)(
                         "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("clone"),
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("clone"),
                             undefined,
-                            [ts.factory.createIdentifier("input")],
+                            [p.tsc.factory.createIdentifier("input")],
                         ),
                     ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createIdentifier("output"),
                     ),
                 ]),
             );

package/src/programmers/AssertParseProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
@@ -9,64 +9,56 @@ import { IProject } from "../transformers/IProject";
 import { AssertProgrammer } from "./AssertProgrammer";
 
 export namespace AssertParseProgrammer {
-    /**
-     * @deprecated Use `write()` function instead
-     */
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            write(project)(modulo)(type, name);
-
     export const write =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+            p.tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(
+                    IdentifierFactory.parameter(p.tsc)(
                         "input",
-                        TypeFactory.keyword("string"),
+                        TypeFactory.keyword(p.tsc)("string"),
                     ),
                 ],
-                ts.factory.createTypeReferenceNode(
+                p.tsc.factory.createTypeReferenceNode(
                     `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
+                        name ?? TypeFactory.getFullName(p)(type)
                     }>`,
                 ),
                 undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
                         "assert",
                         AssertProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(false)(type, name),
                     ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createBinaryExpression(
-                            ts.factory.createIdentifier("input"),
-                            ts.SyntaxKind.EqualsToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("JSON.parse"),
+                    p.tsc.factory.createExpressionStatement(
+                        p.tsc.factory.createBinaryExpression(
+                            p.tsc.factory.createIdentifier("input"),
+                            p.tsc.SyntaxKind.EqualsToken,
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("JSON.parse"),
                                 undefined,
-                                [ts.factory.createIdentifier("input")],
+                                [p.tsc.factory.createIdentifier("input")],
                             ),
                         ),
                     ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("assert"),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createAsExpression(
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("assert"),
                                 undefined,
-                                [ts.factory.createIdentifier("input")],
+                                [p.tsc.factory.createIdentifier("input")],
                             ),
-                            ts.factory.createTypeReferenceNode("any"),
+                            p.tsc.factory.createTypeReferenceNode("any"),
                         ),
                     ),
                 ]),