typia 3.4.6 → 3.4.7

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,4 +1,4 @@
-export interface ITransformOptions {
-    functional?: boolean | "checker" | "stringify";
-    numeric?: boolean | "checker" | "stringify";
-}
+export interface ITransformOptions {
+    functional?: boolean | "checker" | "stringify";
+    numeric?: boolean | "checker" | "stringify";
+}

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;
+    }
+}

package/src/typings/Atomic.ts

@@ -1,17 +1,17 @@
-export namespace Atomic {
-    export type Type = boolean | number | string | bigint;
-    export type Literal =
-        | "boolean"
-        | "integer"
-        | "number"
-        | "string"
-        | "bigint";
-
-    export type Mapper = {
-        boolean: boolean;
-        integer: number;
-        number: number;
-        string: string;
-        bigint: bigint;
-    };
-}
+export namespace Atomic {
+    export type Type = boolean | number | string | bigint;
+    export type Literal =
+        | "boolean"
+        | "integer"
+        | "number"
+        | "string"
+        | "bigint";
+
+    export type Mapper = {
+        boolean: boolean;
+        integer: number;
+        number: number;
+        string: string;
+        bigint: bigint;
+    };
+}

package/src/typings/ClassProperties.ts

@@ -1,5 +1,5 @@
-import { OmitNever } from "./OmitNever";
-
-export type ClassProperties<T extends object> = OmitNever<{
-    [K in keyof T]: T[K] extends Function ? never : T[K];
-}>;
+import { OmitNever } from "./OmitNever";
+
+export type ClassProperties<T extends object> = OmitNever<{
+    [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/src/typings/OmitNever.ts

@@ -1,3 +1,3 @@
-import { SpecialFields } from "./SpecialFields";
-
-export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;
+import { SpecialFields } from "./SpecialFields";
+
+export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;

package/src/typings/SpecialFields.ts

@@ -1,3 +1,3 @@
-export type SpecialFields<Instance extends object, Target> = {
-    [P in keyof Instance]: Instance[P] extends Target ? P : never;
-}[keyof Instance & string];
+export type SpecialFields<Instance extends object, Target> = {
+    [P in keyof Instance]: Instance[P] extends Target ? P : never;
+}[keyof Instance & string];

package/src/typings/Writable.ts

@@ -1,11 +1,11 @@
-import { ClassProperties } from "./ClassProperties";
-
-export type Writable<T extends object> = {
-    -readonly [P in keyof T]: T[P];
-};
-
-export function Writable<T extends object>(
-    elem: T,
-): Writable<ClassProperties<T>> {
-    return elem as any;
-}
+import { ClassProperties } from "./ClassProperties";
+
+export type Writable<T extends object> = {
+    -readonly [P in keyof T]: T[P];
+};
+
+export function Writable<T extends object>(
+    elem: T,
+): Writable<ClassProperties<T>> {
+    return elem as any;
+}

package/src/utils/ArrayUtil.ts

@@ -1,49 +1,49 @@
-export namespace ArrayUtil {
-    export function has<T>(array: T[], pred: (elem: T) => boolean): boolean {
-        return array.some(pred);
-    }
-
-    export function add<T>(
-        array: T[],
-        value: T,
-        pred: (x: T, y: T) => boolean = (x, y) => x === y,
-    ): void {
-        if (array.some((elem) => pred(elem, value))) return;
-        array.push(value);
-    }
-
-    export function set<Key, T>(
-        array: T[],
-        value: T,
-        key: (elem: T) => Key,
-    ): void {
-        if (array.some((elem) => key(elem) === key(value))) return;
-        array.push(value);
-    }
-
-    export function take<T>(
-        array: T[],
-        pred: (elem: T) => boolean,
-        init: () => T,
-    ): T {
-        const index: number = array.findIndex(pred);
-        if (index !== -1) return array[index]!;
-
-        const elem: T = init();
-        array.push(elem);
-        return elem;
-    }
-
-    export function repeat<T>(
-        count: number,
-        closure: (index: number, count: number) => T,
-    ): T[] {
-        return new Array(count)
-            .fill("")
-            .map((_, index) => closure(index, count));
-    }
-
-    export function flat<T>(matrix: T[][]): T[] {
-        return ([] as T[]).concat(...matrix);
-    }
-}
+export namespace ArrayUtil {
+    export function has<T>(array: T[], pred: (elem: T) => boolean): boolean {
+        return array.some(pred);
+    }
+
+    export function add<T>(
+        array: T[],
+        value: T,
+        pred: (x: T, y: T) => boolean = (x, y) => x === y,
+    ): void {
+        if (array.some((elem) => pred(elem, value))) return;
+        array.push(value);
+    }
+
+    export function set<Key, T>(
+        array: T[],
+        value: T,
+        key: (elem: T) => Key,
+    ): void {
+        if (array.some((elem) => key(elem) === key(value))) return;
+        array.push(value);
+    }
+
+    export function take<T>(
+        array: T[],
+        pred: (elem: T) => boolean,
+        init: () => T,
+    ): T {
+        const index: number = array.findIndex(pred);
+        if (index !== -1) return array[index]!;
+
+        const elem: T = init();
+        array.push(elem);
+        return elem;
+    }
+
+    export function repeat<T>(
+        count: number,
+        closure: (index: number, count: number) => T,
+    ): T[] {
+        return new Array(count)
+            .fill("")
+            .map((_, index) => closure(index, count));
+    }
+
+    export function flat<T>(matrix: T[][]): T[] {
+        return ([] as T[]).concat(...matrix);
+    }
+}

package/src/utils/Escaper.ts

@@ -1,50 +1,50 @@
-export namespace Escaper {
-    export function variable(str: string): boolean {
-        return (
-            reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str)
-        );
-    }
-
-    function reserved(str: string): boolean {
-        return RESERVED.has(str);
-    }
-}
-
-const RESERVED: Set<string> = new Set([
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "enum",
-    "export",
-    "extends",
-    "false",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "import",
-    "in",
-    "instanceof",
-    "new",
-    "null",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-]);
+export namespace Escaper {
+    export function variable(str: string): boolean {
+        return (
+            reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str)
+        );
+    }
+
+    function reserved(str: string): boolean {
+        return RESERVED.has(str);
+    }
+}
+
+const RESERVED: Set<string> = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+]);

package/src/utils/MapUtil.ts

@@ -1,14 +1,14 @@
-export namespace MapUtil {
-    export function take<Key, T>(
-        dict: Map<Key, T>,
-        key: Key,
-        generator: () => T,
-    ): T {
-        const oldbie: T | undefined = dict.get(key);
-        if (oldbie) return oldbie;
-
-        const value: T = generator();
-        dict.set(key, value);
-        return value;
-    }
-}
+export namespace MapUtil {
+    export function take<Key, T>(
+        dict: Map<Key, T>,
+        key: Key,
+        generator: () => T,
+    ): T {
+        const oldbie: T | undefined = dict.get(key);
+        if (oldbie) return oldbie;
+
+        const value: T = generator();
+        dict.set(key, value);
+        return value;
+    }
+}