typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/metadata/MetadataProperty.ts

@@ -1,15 +1,15 @@
 import { ClassProperties } from "../typings/ClassProperties";
 
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataDictionary } from "./IMetadataDictionary";
 import { IMetadataProperty } from "./IMetadataProperty";
 import { IMetadataTag } from "./IMetadataTag";
 import { Metadata } from "./Metadata";
-import { MetadataObject } from "./MetadataObject";
 
 export class MetadataProperty {
     public readonly key: Metadata;
     public readonly value: Metadata;
-    public readonly description: string | undefined;
+    public readonly description: string | null;
     public readonly tags: IMetadataTag[];
     public readonly jsDocTags: IJsDocTagInfo[];
 
@@ -41,11 +41,11 @@ export class MetadataProperty {
      */
     public static _From(
         property: IMetadataProperty,
-        objects: Map<string, MetadataObject>,
+        dict: IMetadataDictionary,
     ) {
         return this.create({
-            key: Metadata._From(property.key, objects),
-            value: Metadata._From(property.value, objects),
+            key: Metadata._From(property.key, dict),
+            value: Metadata._From(property.value, dict),
             description: property.description,
             tags: property.tags.slice(),
             jsDocTags: property.jsDocTags.slice(),

package/src/metadata/MetadataTuple.ts

@@ -0,0 +1,53 @@
+import { ClassProperties } from "../typings/ClassProperties";
+
+import { IMetadataTuple } from "./IMetadataTuple";
+import { Metadata } from "./Metadata";
+
+export class MetadataTuple {
+    public readonly name: string;
+    public readonly elements: Metadata[];
+
+    public readonly index: number | null;
+    public readonly recursive: boolean;
+    public readonly nullables: boolean[];
+
+    /**
+     * @internal
+     */
+    private constructor(props: ClassProperties<MetadataTuple>) {
+        this.name = props.name;
+        this.elements = props.elements;
+        this.index = props.index;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_elements(
+        props: Omit<IMetadataTuple, "elements">,
+    ): MetadataTuple {
+        return this.create({
+            name: props.name,
+            index: props.index,
+            elements: null!,
+            recursive: props.recursive,
+            nullables: props.nullables.slice(),
+        });
+    }
+
+    public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
+        return new MetadataTuple(props);
+    }
+
+    public toJSON(): IMetadataTuple {
+        return {
+            name: this.name,
+            index: this.index,
+            elements: this.elements.map((elem) => elem.toJSON()),
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}

package/src/programmers/ApplicationProgrammer.ts

@@ -22,12 +22,20 @@ export namespace ApplicationProgrammer {
         };
     }
 
+    /**
+     * @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 => {
             const fullOptions: IOptions = IOptions.complement(options);
             const components: IJsonComponents = {
-                schemas: {},
+                objects: {},
             };
             const generator = application_schema(fullOptions)(true)(components);
 
@@ -42,7 +50,6 @@ export namespace ApplicationProgrammer {
                 }),
                 components,
                 ...fullOptions,
-                prefix: "#/components/schemas",
             };
         };
 }

package/src/programmers/AssertCloneProgrammer.ts

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

package/src/programmers/AssertParseProgrammer.ts

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