typia 3.7.5 → 3.7.6

package/src/transformers/ExpressionWithArgumentTransformer.ts

@@ -1,66 +1,66 @@
-// import path from "path";
-// import ts from "typescript";
-// import { AssertProgrammer } from "../programmers/AssertProgrammer";
-// import { IsProgrammer } from "../programmers/IsProgrammer";
-// import { StringifyProgrammer } from "../programmers/StringifyProgrammer";
-// import { IProject } from "../structures/IProject";
-
-// export namespace ExpressionWithArgumentTransformer {
-//     export function transform(
-//         project: IProject,
-//         expression: ts.ExpressionWithTypeArguments,
-//     ): ts.Expression {
-//         //----
-//         // VALIDATIONS
-//         //----
-//         // SYMBOL DECLARATION
-//         const symbol: ts.Symbol | undefined =
-//             project.checker.getSymbolAtLocation(expression.expression);
-//         const declaration: ts.Declaration | undefined = symbol?.declarations
-//             ? symbol.declarations[0]
-//             : undefined;
-//         if (!declaration) return expression;
-
-//         // FILE PATH
-//         const file: string = path.resolve(declaration.getSourceFile().fileName);
-//         if (file !== LIB_PATH && file !== SRC_PATH) return expression;
-
-//         // ARGUMENTS
-//         if (expression.typeArguments?.length !== 1) return expression;
-
-//         //----
-//         // TRANSFORMATION
-//         //----
-//         // GET MODULO AND TYPE
-//         const modulo: ts.LeftHandSideExpression = expression.expression;
-//         const type: ts.Type = project.checker.getTypeFromTypeNode(
-//             expression.typeArguments[0]!,
-//         );
-
-//         // FUNCTION NAME
-//         const { name } = project.checker.getTypeAtLocation(declaration).symbol;
-
-//         // FIND TRANSFORMER
-//         const functor: (() => Task) | undefined = FUNCTORS[name];
-//         if (functor === undefined) return expression;
-
-//         // RETURNS WITH TRANSFORMATION
-//         return functor()(project, modulo, type);
-//     }
-// }
-
-// type Task = (
-//     project: IProject,
-//     modulo: ts.LeftHandSideExpression,
-//     type: ts.Type,
-// ) => ts.ArrowFunction;
-
-// const LIB_PATH = path.resolve(path.join(__dirname, "..", "module.d.ts"));
-// const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
-
-// const FUNCTORS: Record<string, () => Task> = {
-//     assert: () => AssertProgrammer.generate,
-//     is: () => (project, _modulo, type) => IsProgrammer.generate(project, type),
-//     stringify: () => (project, modulo, type) =>
-//         StringifyProgrammer.generate(modulo)(project, type),
-// };
+// import path from "path";
+// import ts from "typescript";
+// import { AssertProgrammer } from "../programmers/AssertProgrammer";
+// import { IsProgrammer } from "../programmers/IsProgrammer";
+// import { StringifyProgrammer } from "../programmers/StringifyProgrammer";
+// import { IProject } from "../structures/IProject";
+
+// export namespace ExpressionWithArgumentTransformer {
+//     export function transform(
+//         project: IProject,
+//         expression: ts.ExpressionWithTypeArguments,
+//     ): ts.Expression {
+//         //----
+//         // VALIDATIONS
+//         //----
+//         // SYMBOL DECLARATION
+//         const symbol: ts.Symbol | undefined =
+//             project.checker.getSymbolAtLocation(expression.expression);
+//         const declaration: ts.Declaration | undefined = symbol?.declarations
+//             ? symbol.declarations[0]
+//             : undefined;
+//         if (!declaration) return expression;
+
+//         // FILE PATH
+//         const file: string = path.resolve(declaration.getSourceFile().fileName);
+//         if (file !== LIB_PATH && file !== SRC_PATH) return expression;
+
+//         // ARGUMENTS
+//         if (expression.typeArguments?.length !== 1) return expression;
+
+//         //----
+//         // TRANSFORMATION
+//         //----
+//         // GET MODULO AND TYPE
+//         const modulo: ts.LeftHandSideExpression = expression.expression;
+//         const type: ts.Type = project.checker.getTypeFromTypeNode(
+//             expression.typeArguments[0]!,
+//         );
+
+//         // FUNCTION NAME
+//         const { name } = project.checker.getTypeAtLocation(declaration).symbol;
+
+//         // FIND TRANSFORMER
+//         const functor: (() => Task) | undefined = FUNCTORS[name];
+//         if (functor === undefined) return expression;
+
+//         // RETURNS WITH TRANSFORMATION
+//         return functor()(project, modulo, type);
+//     }
+// }
+
+// type Task = (
+//     project: IProject,
+//     modulo: ts.LeftHandSideExpression,
+//     type: ts.Type,
+// ) => ts.ArrowFunction;
+
+// const LIB_PATH = path.resolve(path.join(__dirname, "..", "module.d.ts"));
+// const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
+
+// const FUNCTORS: Record<string, () => Task> = {
+//     assert: () => AssertProgrammer.generate,
+//     is: () => (project, _modulo, type) => IsProgrammer.generate(project, type),
+//     stringify: () => (project, modulo, type) =>
+//         StringifyProgrammer.generate(modulo)(project, type),
+// };

package/src/transformers/FileTransformer.ts

@@ -1,49 +1,49 @@
-import ts from "typescript";
-
-import { IProject } from "./IProject";
-import { NodeTransformer } from "./NodeTransformer";
-
-export namespace FileTransformer {
-    export function transform(
-        project: IProject,
-        context: ts.TransformationContext,
-        file: ts.SourceFile,
-    ): ts.SourceFile {
-        // DO NOT TRANSFORM D.TS FILE
-        if (file.isDeclarationFile) return file;
-
-        // ITERATE NODES
-        return ts.visitEachChild(
-            file,
-            (node) => iterate_node(project, context, node),
-            context,
-        );
-    }
-
-    function iterate_node(
-        project: IProject,
-        context: ts.TransformationContext,
-        node: ts.Node,
-    ): ts.Node {
-        return ts.visitEachChild(
-            try_transform_node(project, node),
-            (child) => iterate_node(project, context, child),
-            context,
-        );
-    }
-
-    function try_transform_node(project: IProject, node: ts.Node): ts.Node {
-        try {
-            return NodeTransformer.transform(project, node);
-        } catch (exp) {
-            if (!(exp instanceof Error)) throw exp;
-
-            const file: ts.SourceFile = node.getSourceFile();
-            const { line, character } = file.getLineAndCharacterOfPosition(
-                node.pos,
-            );
-            exp.message += ` - ${file.fileName}:${line + 1}:${character + 1}`;
-            throw exp;
-        }
-    }
-}
+import ts from "typescript";
+
+import { IProject } from "./IProject";
+import { NodeTransformer } from "./NodeTransformer";
+
+export namespace FileTransformer {
+    export function transform(
+        project: IProject,
+        context: ts.TransformationContext,
+        file: ts.SourceFile,
+    ): ts.SourceFile {
+        // DO NOT TRANSFORM D.TS FILE
+        if (file.isDeclarationFile) return file;
+
+        // ITERATE NODES
+        return ts.visitEachChild(
+            file,
+            (node) => iterate_node(project, context, node),
+            context,
+        );
+    }
+
+    function iterate_node(
+        project: IProject,
+        context: ts.TransformationContext,
+        node: ts.Node,
+    ): ts.Node {
+        return ts.visitEachChild(
+            try_transform_node(project, node),
+            (child) => iterate_node(project, context, child),
+            context,
+        );
+    }
+
+    function try_transform_node(project: IProject, node: ts.Node): ts.Node {
+        try {
+            return NodeTransformer.transform(project, node);
+        } catch (exp) {
+            if (!(exp instanceof Error)) throw exp;
+
+            const file: ts.SourceFile = node.getSourceFile();
+            const { line, character } = file.getLineAndCharacterOfPosition(
+                node.pos,
+            );
+            exp.message += ` - ${file.fileName}:${line + 1}:${character + 1}`;
+            throw exp;
+        }
+    }
+}

package/src/transformers/IProject.ts

@@ -1,11 +1,11 @@
-import ts from "typescript";
-
-import { ITransformOptions } from "./ITransformOptions";
-
-export interface IProject {
-    program: ts.Program;
-    compilerOptions: ts.CompilerOptions;
-    checker: ts.TypeChecker;
-    printer: ts.Printer;
-    options: ITransformOptions;
-}
+import ts from "typescript";
+
+import { ITransformOptions } from "./ITransformOptions";
+
+export interface IProject {
+    program: ts.Program;
+    compilerOptions: ts.CompilerOptions;
+    checker: ts.TypeChecker;
+    printer: ts.Printer;
+    options: ITransformOptions;
+}

package/src/transformers/ITransformOptions.ts

@@ -1,62 +1,62 @@
-export interface ITransformOptions {
-    /**
-     * Whether to validate finite number or not.
-     *
-     * If configured true, number typed values would be validated by Number.isNaN().
-     *
-     * However, whatever you configure, it would be ignored when marshaling or parsing.
-     *
-     *   - when marshaling, always be true
-     *     - assertStringify()
-     *     - validateEncode()
-     *   - when parsing, always be false
-     *     - assertParse()
-     *     - isDecode()
-     *
-     * @default false
-     */
-    finite?: boolean;
-
-    /**
-     * Whether to validate finite number or not.
-     *
-     * If configured true, number typed values would be validated by Number.isFinite().
-     *
-     * However, whatever you configure, it can be ignored in below case.
-     *
-     *   - when `finite` option is true, this option would be ignored
-     *   - when marshaling, always be true
-     *     - assertStringify()
-     *     - validateEncode()
-     *   - when parsing, always be false
-     *     - assertParse()
-     *     - isDecode()
-     *
-     * @default false
-     */
-    numeric?: boolean;
-
-    /**
-     * Whether to validate functional type or not.
-     *
-     * However, whatever you configure, it becomes false when marshaling or parsing.
-     *
-     * @default false
-     */
-    functional?: boolean;
-
-    /**
-     * Whether to check undefined value or not.
-     *
-     * JavaScript can assign `undefined` value to a specific property and it is an
-     * issue when validating without allowing superfluous properties. Should undefined
-     * value assigned superfluous property be allowed or not?
-     *
-     * Note that, this option only works on {@link equals} function. Other function
-     * like {@link assertEquals} or {@link validateEquals} would ignore this option
-     * value and always allow the `undefined` value.
-     *
-     * @default true
-     */
-    undefined?: boolean;
-}
+export interface ITransformOptions {
+    /**
+     * Whether to validate finite number or not.
+     *
+     * If configured true, number typed values would be validated by Number.isNaN().
+     *
+     * However, whatever you configure, it would be ignored when marshaling or parsing.
+     *
+     *   - when marshaling, always be true
+     *     - assertStringify()
+     *     - validateEncode()
+     *   - when parsing, always be false
+     *     - assertParse()
+     *     - isDecode()
+     *
+     * @default false
+     */
+    finite?: boolean;
+
+    /**
+     * Whether to validate finite number or not.
+     *
+     * If configured true, number typed values would be validated by Number.isFinite().
+     *
+     * However, whatever you configure, it can be ignored in below case.
+     *
+     *   - when `finite` option is true, this option would be ignored
+     *   - when marshaling, always be true
+     *     - assertStringify()
+     *     - validateEncode()
+     *   - when parsing, always be false
+     *     - assertParse()
+     *     - isDecode()
+     *
+     * @default false
+     */
+    numeric?: boolean;
+
+    /**
+     * Whether to validate functional type or not.
+     *
+     * However, whatever you configure, it becomes false when marshaling or parsing.
+     *
+     * @default false
+     */
+    functional?: boolean;
+
+    /**
+     * Whether to check undefined value or not.
+     *
+     * JavaScript can assign `undefined` value to a specific property and it is an
+     * issue when validating without allowing superfluous properties. Should undefined
+     * value assigned superfluous property be allowed or not?
+     *
+     * Note that, this option only works on {@link equals} function. Other function
+     * like {@link assertEquals} or {@link validateEquals} would ignore this option
+     * value and always allow the `undefined` value.
+     *
+     * @default true
+     */
+    undefined?: boolean;
+}

package/src/transformers/ImportTransformer.ts

@@ -1,66 +1,66 @@
-import path from "path";
-import ts from "typescript";
-
-export namespace ImportTransformer {
-    export const transform =
-        (from: string) =>
-        (to: string) =>
-        (context: ts.TransformationContext) =>
-        (file: ts.SourceFile) =>
-            transform_file(from)(to)(context)(file);
-
-    const transform_file =
-        (top: string) =>
-        (to: string) =>
-        (context: ts.TransformationContext) =>
-        (file: ts.SourceFile): ts.SourceFile => {
-            if (file.isDeclarationFile) return file;
-
-            const from: string = get_directory_path(
-                path.resolve(file.getSourceFile().fileName),
-            );
-            to = from.replace(top, to);
-
-            return ts.visitEachChild(
-                file,
-                (node) => transform_node(top)(from)(to)(node),
-                context,
-            );
-        };
-
-    const transform_node =
-        (top: string) => (from: string) => (to: string) => (node: ts.Node) => {
-            if (
-                !ts.isImportDeclaration(node) ||
-                !ts.isStringLiteral(node.moduleSpecifier)
-            )
-                return node;
-
-            const text: string = node.moduleSpecifier.text;
-            if (text[0] !== ".") return node;
-
-            const location: string = path.resolve(from, text);
-            if (location.indexOf(top) === 0) return node;
-
-            const replaced: string = (() => {
-                const simple: string = path
-                    .relative(to, location)
-                    .split(path.sep)
-                    .join("/");
-                return simple[0] === "." ? simple : `./${simple}`;
-            })();
-
-            return ts.factory.createImportDeclaration(
-                undefined,
-                node.importClause,
-                ts.factory.createStringLiteral(replaced),
-                node.assertClause,
-            );
-        };
-}
-
-const get_directory_path = (file: string): string => {
-    const splitted: string[] = path.resolve(file).split(path.sep);
-    splitted.pop();
-    return path.resolve(splitted.join(path.sep));
-};
+import path from "path";
+import ts from "typescript";
+
+export namespace ImportTransformer {
+    export const transform =
+        (from: string) =>
+        (to: string) =>
+        (context: ts.TransformationContext) =>
+        (file: ts.SourceFile) =>
+            transform_file(from)(to)(context)(file);
+
+    const transform_file =
+        (top: string) =>
+        (to: string) =>
+        (context: ts.TransformationContext) =>
+        (file: ts.SourceFile): ts.SourceFile => {
+            if (file.isDeclarationFile) return file;
+
+            const from: string = get_directory_path(
+                path.resolve(file.getSourceFile().fileName),
+            );
+            to = from.replace(top, to);
+
+            return ts.visitEachChild(
+                file,
+                (node) => transform_node(top)(from)(to)(node),
+                context,
+            );
+        };
+
+    const transform_node =
+        (top: string) => (from: string) => (to: string) => (node: ts.Node) => {
+            if (
+                !ts.isImportDeclaration(node) ||
+                !ts.isStringLiteral(node.moduleSpecifier)
+            )
+                return node;
+
+            const text: string = node.moduleSpecifier.text;
+            if (text[0] !== ".") return node;
+
+            const location: string = path.resolve(from, text);
+            if (location.indexOf(top) === 0) return node;
+
+            const replaced: string = (() => {
+                const simple: string = path
+                    .relative(to, location)
+                    .split(path.sep)
+                    .join("/");
+                return simple[0] === "." ? simple : `./${simple}`;
+            })();
+
+            return ts.factory.createImportDeclaration(
+                undefined,
+                node.importClause,
+                ts.factory.createStringLiteral(replaced),
+                node.assertClause,
+            );
+        };
+}
+
+const get_directory_path = (file: string): string => {
+    const splitted: string[] = path.resolve(file).split(path.sep);
+    splitted.pop();
+    return path.resolve(splitted.join(path.sep));
+};

package/src/transformers/NodeTransformer.ts

@@ -1,19 +1,19 @@
-import ts from "typescript";
-
-import { CallExpressionTransformer } from "./CallExpressionTransformer";
-import { IProject } from "./IProject";
-
-// import { ExpressionWithArgumentTransformer } from "./ExpressionWithArgumentTransformer";
-
-export namespace NodeTransformer {
-    export function transform(project: IProject, expression: ts.Node): ts.Node {
-        if (ts.isCallExpression(expression))
-            return CallExpressionTransformer.transform(project, expression);
-        // else if (ts.isExpressionWithTypeArguments(expression))
-        //     return ExpressionWithArgumentTransformer.transform(
-        //         project,
-        //         expression,
-        //     );
-        return expression;
-    }
-}
+import ts from "typescript";
+
+import { CallExpressionTransformer } from "./CallExpressionTransformer";
+import { IProject } from "./IProject";
+
+// import { ExpressionWithArgumentTransformer } from "./ExpressionWithArgumentTransformer";
+
+export namespace NodeTransformer {
+    export function transform(project: IProject, expression: ts.Node): ts.Node {
+        if (ts.isCallExpression(expression))
+            return CallExpressionTransformer.transform(project, expression);
+        // else if (ts.isExpressionWithTypeArguments(expression))
+        //     return ExpressionWithArgumentTransformer.transform(
+        //         project,
+        //         expression,
+        //     );
+        return expression;
+    }
+}