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

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { TemplateFactory } from "../../factories/TemplateFactory";
@@ -9,159 +9,165 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 /**
  * @internal
  */
-export const stringify_dynamic_properties = (
-    dynamic: IExpressionEntry<ts.Expression>[],
-    regular: string[],
-): ts.Expression => {
-    // BASIC STATMEMENT, CHECK UNDEFINED
-    const statements: ts.Statement[] = [
-        ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                ts.factory.createIdentifier("value"),
-            ),
-            ts.factory.createReturnStatement(
-                ts.factory.createStringLiteral(""),
+export const stringify_dynamic_properties =
+    (tsc: typeof ts) =>
+    (
+        dynamic: IExpressionEntry<ts.Expression>[],
+        regular: string[],
+    ): ts.Expression => {
+        // BASIC STATMEMENT, CHECK UNDEFINED
+        const statements: ts.Statement[] = [
+            tsc.factory.createIfStatement(
+                tsc.factory.createStrictEquality(
+                    tsc.factory.createIdentifier("undefined"),
+                    tsc.factory.createIdentifier("value"),
+                ),
+                tsc.factory.createReturnStatement(
+                    tsc.factory.createStringLiteral(""),
+                ),
             ),
-        ),
-    ];
+        ];
 
-    // PREPARE RETURN FUNCTION
-    const output = () => {
-        const mapped = ts.factory.createCallExpression(
-            IdentifierFactory.access(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [ts.factory.createIdentifier("input")],
-                ),
-            )("map"),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [
-                        IdentifierFactory.parameter(
-                            ts.factory.createArrayBindingPattern([
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    "key",
-                                ),
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    "value",
+        // PREPARE RETURN FUNCTION
+        const output = () => {
+            const mapped = tsc.factory.createCallExpression(
+                IdentifierFactory.access(tsc)(
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier("Object.entries"),
+                        undefined,
+                        [tsc.factory.createIdentifier("input")],
+                    ),
+                )("map"),
+                undefined,
+                [
+                    tsc.factory.createArrowFunction(
+                        undefined,
+                        undefined,
+                        [
+                            IdentifierFactory.parameter(tsc)(
+                                tsc.factory.createArrayBindingPattern([
+                                    tsc.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        "key",
+                                    ),
+                                    tsc.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        "value",
+                                    ),
+                                ]),
+                                tsc.factory.createTypeReferenceNode(
+                                    "[string, any]",
                                 ),
-                            ]),
-                            ts.factory.createTypeReferenceNode("[string, any]"),
+                            ),
+                        ],
+                        undefined,
+                        undefined,
+                        tsc.factory.createBlock(statements),
+                    ),
+                ],
+            );
+            const filtered = tsc.factory.createCallExpression(
+                IdentifierFactory.access(tsc)(mapped)("filter"),
+                undefined,
+                [
+                    tsc.factory.createArrowFunction(
+                        undefined,
+                        undefined,
+                        [IdentifierFactory.parameter(tsc)("str")],
+                        undefined,
+                        undefined,
+                        tsc.factory.createStrictInequality(
+                            tsc.factory.createStringLiteral(""),
+                            tsc.factory.createIdentifier("str"),
                         ),
-                    ],
-                    undefined,
-                    undefined,
-                    ts.factory.createBlock(statements),
-                ),
-            ],
-        );
-        const filtered = ts.factory.createCallExpression(
-            IdentifierFactory.access(mapped)("filter"),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [IdentifierFactory.parameter("str")],
-                    undefined,
-                    undefined,
-                    ts.factory.createStrictInequality(
-                        ts.factory.createStringLiteral(""),
-                        ts.factory.createIdentifier("str"),
                     ),
-                ),
-            ],
-        );
-        return ts.factory.createCallExpression(
-            IdentifierFactory.access(filtered)("join"),
-            undefined,
-            [ts.factory.createStringLiteral(",")],
-        );
-    };
+                ],
+            );
+            return tsc.factory.createCallExpression(
+                IdentifierFactory.access(tsc)(filtered)("join"),
+                undefined,
+                [tsc.factory.createStringLiteral(",")],
+            );
+        };
 
-    // WHEN REGULAR PROPERTY EXISTS
-    if (regular.length)
-        statements.push(
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                        ts.factory.createArrayLiteralExpression(
-                            regular.map((key) =>
-                                ts.factory.createStringLiteral(key),
+        // WHEN REGULAR PROPERTY EXISTS
+        if (regular.length)
+            statements.push(
+                tsc.factory.createIfStatement(
+                    tsc.factory.createCallExpression(
+                        IdentifierFactory.access(tsc)(
+                            tsc.factory.createArrayLiteralExpression(
+                                regular.map((key) =>
+                                    tsc.factory.createStringLiteral(key),
+                                ),
                             ),
-                        ),
-                    )("some"),
-                    undefined,
-                    [
-                        ts.factory.createArrowFunction(
-                            undefined,
-                            undefined,
-                            [IdentifierFactory.parameter("regular")],
-                            undefined,
-                            undefined,
-                            ts.factory.createStrictEquality(
-                                ts.factory.createIdentifier("regular"),
-                                ts.factory.createIdentifier("key"),
+                        )("some"),
+                        undefined,
+                        [
+                            tsc.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [IdentifierFactory.parameter(tsc)("regular")],
+                                undefined,
+                                undefined,
+                                tsc.factory.createStrictEquality(
+                                    tsc.factory.createIdentifier("regular"),
+                                    tsc.factory.createIdentifier("key"),
+                                ),
                             ),
-                        ),
-                    ],
-                ),
-                ts.factory.createReturnStatement(
-                    ts.factory.createStringLiteral(""),
+                        ],
+                    ),
+                    tsc.factory.createReturnStatement(
+                        tsc.factory.createStringLiteral(""),
+                    ),
                 ),
-            ),
-        );
+            );
 
-    // ONLY STRING TYPED KEY EXISTS
-    const simple: boolean =
-        dynamic.length === 1 &&
-        dynamic[0]!.key.size() === 1 &&
-        dynamic[0]!.key.atomics[0] === "string";
-    if (simple === true) {
-        statements.push(stringify(dynamic[0]!));
-        return output();
-    }
+        // ONLY STRING TYPED KEY EXISTS
+        const simple: boolean =
+            dynamic.length === 1 &&
+            dynamic[0]!.key.size() === 1 &&
+            dynamic[0]!.key.atomics[0] === "string";
+        if (simple === true) {
+            statements.push(stringify(tsc)(dynamic[0]!));
+            return output();
+        }
 
-    // COMPOSITE TEMPLATE LITERAL TYPES
-    for (const entry of dynamic) {
-        const condition: ts.IfStatement = ts.factory.createIfStatement(
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                    `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+        // COMPOSITE TEMPLATE LITERAL TYPES
+        for (const entry of dynamic) {
+            const condition: ts.IfStatement = tsc.factory.createIfStatement(
+                tsc.factory.createCallExpression(
+                    tsc.factory.createIdentifier(
+                        `RegExp(/${metadata_to_pattern(true)(
+                            entry.key,
+                        )}/).test`,
+                    ),
+                    undefined,
+                    [tsc.factory.createIdentifier("key")],
                 ),
-                undefined,
-                [ts.factory.createIdentifier("key")],
-            ),
-            stringify(entry),
-        );
-        statements.push(condition);
-    }
-    return output();
-};
+                stringify(tsc)(entry),
+            );
+            statements.push(condition);
+        }
+        return output();
+    };
 
 /**
  * @internal
  */
-const stringify = (
-    entry: IExpressionEntry<ts.Expression>,
-): ts.ReturnStatement =>
-    ts.factory.createReturnStatement(
-        TemplateFactory.generate([
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("JSON.stringify"),
-                [],
-                [ts.factory.createIdentifier("key")],
-            ),
-            ts.factory.createStringLiteral(":"),
-            entry.expression,
-        ]),
-    );
+const stringify =
+    (tsc: typeof ts) =>
+    (entry: IExpressionEntry<ts.Expression>): ts.ReturnStatement =>
+        tsc.factory.createReturnStatement(
+            TemplateFactory.generate(tsc)([
+                tsc.factory.createCallExpression(
+                    tsc.factory.createIdentifier("JSON.stringify"),
+                    [],
+                    [tsc.factory.createIdentifier("key")],
+                ),
+                tsc.factory.createStringLiteral(":"),
+                entry.expression,
+            ]),
+        );

package/src/programmers/internal/stringify_native.ts

@@ -1,7 +1,7 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 /**
  * @internal
  */
-export const stringify_native = (): ts.Expression =>
-    ts.factory.createStringLiteral("{}");
+export const stringify_native = (tsc: typeof ts): ts.Expression =>
+    tsc.factory.createStringLiteral("{}");

package/src/programmers/internal/stringify_regular_properties.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { TemplateFactory } from "../../factories/TemplateFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
@@ -10,71 +10,77 @@ import { IExpressionEntry } from "../helpers/IExpressionEntry";
 /**
  * @internal
  */
-export const stringify_regular_properties = (
-    regular: IExpressionEntry<ts.Expression>[],
-    dynamic: IExpressionEntry<ts.Expression>[],
-): ts.Expression[] => {
-    const output: ts.Expression[] = [];
+export const stringify_regular_properties =
+    (tsc: typeof ts) =>
+    (
+        regular: IExpressionEntry<ts.Expression>[],
+        dynamic: IExpressionEntry<ts.Expression>[],
+    ): ts.Expression[] => {
+        const output: ts.Expression[] = [];
 
-    regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
-    regular.forEach((entry, index) => {
-        // BASE ELEMENTS
-        const key: string = entry.key.getSoleLiteral()!;
-        const base: ts.Expression[] = [
-            ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
-            entry.expression,
-        ];
-        if (index !== regular.length - 1 || dynamic.length !== 0)
-            base.push(ts.factory.createStringLiteral(`,`));
+        regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
+        regular.forEach((entry, index) => {
+            // BASE ELEMENTS
+            const key: string = entry.key.getSoleLiteral()!;
+            const base: ts.Expression[] = [
+                tsc.factory.createStringLiteral(`${JSON.stringify(key)}:`),
+                entry.expression,
+            ];
+            if (index !== regular.length - 1 || dynamic.length !== 0)
+                base.push(tsc.factory.createStringLiteral(`,`));
 
-        const empty: boolean =
-            (entry.meta.required === false &&
-                entry.meta.nullable === false &&
-                entry.meta.size() === 0) ||
-            (entry.meta.functional &&
-                entry.meta.nullable === false &&
-                entry.meta.size() === 1);
+            const empty: boolean =
+                (entry.meta.required === false &&
+                    entry.meta.nullable === false &&
+                    entry.meta.size() === 0) ||
+                (entry.meta.functional &&
+                    entry.meta.nullable === false &&
+                    entry.meta.size() === 1);
 
-        if (empty === true) return;
-        else if (
-            entry.meta.required === false ||
-            entry.meta.functional === true ||
-            entry.meta.any === true
-        )
-            output.push(
-                ts.factory.createConditionalExpression(
-                    (() => {
-                        const conditions: ts.BinaryExpression[] = [];
-                        if (entry.meta.required === false || entry.meta.any)
-                            conditions.push(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createIdentifier("undefined"),
-                                    entry.input,
-                                ),
-                            );
-                        if (entry.meta.functional || entry.meta.any)
-                            conditions.push(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createStringLiteral("function"),
-                                    ValueFactory.TYPEOF(entry.input),
-                                ),
-                            );
-                        return conditions.length === 1
-                            ? conditions[0]!
-                            : conditions.reduce((x, y) =>
-                                  ts.factory.createLogicalOr(x, y),
-                              );
-                    })(),
-                    undefined,
-                    ts.factory.createStringLiteral(""),
-                    undefined,
-                    TemplateFactory.generate(base),
-                ),
-            );
-        else output.push(...base);
-    });
-    return output;
-};
+            if (empty === true) return;
+            else if (
+                entry.meta.required === false ||
+                entry.meta.functional === true ||
+                entry.meta.any === true
+            )
+                output.push(
+                    tsc.factory.createConditionalExpression(
+                        (() => {
+                            const conditions: ts.BinaryExpression[] = [];
+                            if (entry.meta.required === false || entry.meta.any)
+                                conditions.push(
+                                    tsc.factory.createStrictEquality(
+                                        tsc.factory.createIdentifier(
+                                            "undefined",
+                                        ),
+                                        entry.input,
+                                    ),
+                                );
+                            if (entry.meta.functional || entry.meta.any)
+                                conditions.push(
+                                    tsc.factory.createStrictEquality(
+                                        tsc.factory.createStringLiteral(
+                                            "function",
+                                        ),
+                                        ValueFactory.TYPEOF(tsc)(entry.input),
+                                    ),
+                                );
+                            return conditions.length === 1
+                                ? conditions[0]!
+                                : conditions.reduce((x, y) =>
+                                      tsc.factory.createLogicalOr(x, y),
+                                  );
+                        })(),
+                        undefined,
+                        tsc.factory.createStringLiteral(""),
+                        undefined,
+                        TemplateFactory.generate(tsc)(base),
+                    ),
+                );
+            else output.push(...base);
+        });
+        return output;
+    };
 
 /**
  * @internal

package/src/schemas/IJsonApplication.ts

@@ -5,5 +5,9 @@ export interface IJsonApplication {
     schemas: IJsonSchema[];
     components: IJsonComponents;
     purpose: "swagger" | "ajv";
+
+    /**
+     * @deprecated Always "#/components/schemas"
+     */
     prefix: string;
 }

package/src/schemas/IJsonComponents.ts

@@ -7,11 +7,18 @@ export interface IJsonComponents {
 }
 export namespace IJsonComponents {
     export interface IObject {
+        /**
+         * Used only when ajv mode.
+         */
         $id?: string;
         $recursiveAnchor?: boolean;
 
         type: "object";
-        nullable: boolean;
+
+        /**
+         * Only when swagger mode.
+         */
+        nullable?: boolean;
 
         properties: Record<string, IJsonSchema>;
         patternProperties?: Record<string, IJsonSchema>;

package/src/schemas/IJsonSchema.ts

@@ -21,7 +21,7 @@ export namespace IJsonSchema {
         | INullOnly;
 
     export interface IUnknown extends IAttribute {
-        type: undefined;
+        type?: undefined;
     }
 
     /**
@@ -115,7 +115,11 @@ export namespace IJsonSchema {
 
     export interface ISignificant<Literal extends string> extends IAttribute {
         type: Literal;
-        nullable: boolean;
+
+        /**
+         * Only when swagger mode.
+         */
+        nullable?: boolean;
     }
     export interface IAttribute {
         deprecated?: boolean;

package/src/transform.ts

@@ -1,17 +1,20 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { FileTransformer } from "./transformers/FileTransformer";
-import { ITransformOptions } from "./transformers/ITransformOptions";
 
-export const transform = (
-    program: ts.Program,
-    options?: ITransformOptions,
-): ts.TransformerFactory<ts.SourceFile> =>
-    FileTransformer.transform({
-        program,
-        compilerOptions: program.getCompilerOptions(),
-        checker: program.getTypeChecker(),
-        printer: ts.createPrinter(),
-        options: options || {},
-    });
-export default transform;
+const transform: ts.CustomTransformersModuleFactory = ({ typescript }) => ({
+    create: (info) => ({
+        before: [
+            (context) => (file) =>
+                FileTransformer.transform({
+                    tsc: typescript,
+                    program: info.program,
+                    compilerOptions: info.program.getCompilerOptions(),
+                    checker: info.program.getTypeChecker(),
+                    printer: typescript.createPrinter(),
+                    options: info.config ?? {},
+                })(context)(file),
+        ],
+    }),
+});
+export = transform;