typia 5.0.4 → 5.0.5-dev.20230921-2

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,13 +1,13 @@
-import ts from "typescript";
-
-import { CallExpressionTransformer } from "./CallExpressionTransformer";
-import { IProject } from "./IProject";
-
-export namespace NodeTransformer {
-    export const transform =
-        (project: IProject) =>
-        (expression: ts.Node): ts.Node | null =>
-            ts.isCallExpression(expression) && expression.parent
-                ? CallExpressionTransformer.transform(project)(expression)
-                : expression;
-}
+import ts from "typescript";
+
+import { CallExpressionTransformer } from "./CallExpressionTransformer";
+import { IProject } from "./IProject";
+
+export namespace NodeTransformer {
+    export const transform =
+        (project: IProject) =>
+        (expression: ts.Node): ts.Node | null =>
+            ts.isCallExpression(expression) && expression.parent
+                ? CallExpressionTransformer.transform(project)(expression)
+                : expression;
+}

package/src/transformers/TransformerError.ts

@@ -1,55 +1,55 @@
-import { MetadataFactory } from "../factories/MetadataFactory";
-
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-
-import { Escaper } from "../utils/Escaper";
-
-export class TransformerError extends Error {
-    public readonly code: string;
-
-    public constructor(props: TransformerError.IProps) {
-        super(props.message);
-        this.code = props.code;
-
-        // INHERITANCE POLYFILL
-        const proto = new.target.prototype;
-        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
-        else (this as any).__proto__ = proto;
-    }
-}
-export namespace TransformerError {
-    export interface IProps {
-        code: string;
-        message: string;
-    }
-
-    export const from =
-        (method: string) =>
-        (errors: MetadataFactory.IError[]): TransformerError => {
-            const body: string = errors
-                .map((e) => {
-                    const subject: string =
-                        e.explore.object === null
-                            ? ""
-                            : join(e.explore.object)(e.explore.property);
-                    const type: string = `${
-                        subject.length ? `${subject}: ` : ""
-                    }${e.name}`;
-                    return `- ${type}\n${e.messages
-                        .map((msg) => `  - ${msg}`)
-                        .join("\n")}`;
-                })
-                .join("\n\n");
-            return new TransformerError({
-                code: method,
-                message: `unsupported type detected\n\n${body}`,
-            });
-        };
-
-    const join = (object: MetadataObject) => (key: string | object | null) => {
-        if (key === null) return object.name;
-        else if (typeof key === "object") return `${object.name}[key]`;
-        else if (Escaper.variable(key)) return `${object.name}.${key}`;
-        return `${object.name}[${JSON.stringify(key)}]`;
-    };
-}
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+import { Escaper } from "../utils/Escaper";
+
+export class TransformerError extends Error {
+    public readonly code: string;
+
+    public constructor(props: TransformerError.IProps) {
+        super(props.message);
+        this.code = props.code;
+
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+        else (this as any).__proto__ = proto;
+    }
+}
+export namespace TransformerError {
+    export interface IProps {
+        code: string;
+        message: string;
+    }
+
+    export const from =
+        (method: string) =>
+        (errors: MetadataFactory.IError[]): TransformerError => {
+            const body: string = errors
+                .map((e) => {
+                    const subject: string =
+                        e.explore.object === null
+                            ? ""
+                            : join(e.explore.object)(e.explore.property);
+                    const type: string = `${
+                        subject.length ? `${subject}: ` : ""
+                    }${e.name}`;
+                    return `- ${type}\n${e.messages
+                        .map((msg) => `  - ${msg}`)
+                        .join("\n")}`;
+                })
+                .join("\n\n");
+            return new TransformerError({
+                code: method,
+                message: `unsupported type detected\n\n${body}`,
+            });
+        };
+
+    const join = (object: MetadataObject) => (key: string | object | null) => {
+        if (key === null) return object.name;
+        else if (typeof key === "object") return `${object.name}[key]`;
+        else if (Escaper.variable(key)) return `${object.name}.${key}`;
+        return `${object.name}[${JSON.stringify(key)}]`;
+    };
+}

package/src/transformers/features/AssertTransformer.ts

@@ -1,11 +1,11 @@
-import { AssertProgrammer } from "../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace AssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
-            (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace AssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/CreateAssertTransformer.ts

@@ -1,13 +1,13 @@
-import { AssertProgrammer } from "../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateAssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createAssertEquals" : "createAssert",
-        )(
-            (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateAssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createAssertEquals" : "createAssert",
+        )(
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/CreateIsTransformer.ts

@@ -1,11 +1,11 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateIsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
-            (project) => (modulo) =>
-                IsProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateIsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/CreateRandomTransformer.ts

@@ -1,43 +1,43 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../programmers/RandomProgrammer";
-
-import { IProject } from "../IProject";
-import { TransformerError } from "../TransformerError";
-
-export namespace CreateRandomTransformer {
-    export const transform =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0])
-                throw new TransformerError({
-                    code: "typia.createRandom",
-                    message: "generic argument is not specified.",
-                });
-
-            // GET TYPE INFO
-            const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-            if (type.isTypeParameter())
-                throw new TransformerError({
-                    code: "typia.createRandom",
-                    message: "non-specified generic argument.",
-                });
-
-            // DO TRANSFORM
-            return RandomProgrammer.write({
-                ...project,
-                options: {
-                    ...project.options,
-                    functional: false,
-                    numeric: false,
-                },
-            })(modulo)(expression.arguments?.[0])(
-                type,
-                node.getFullText().trim(),
-            );
-        };
-}
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../programmers/RandomProgrammer";
+
+import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
+
+export namespace CreateRandomTransformer {
+    export const transform =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "generic argument is not specified.",
+                });
+
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "non-specified generic argument.",
+                });
+
+            // DO TRANSFORM
+            return RandomProgrammer.write({
+                ...project,
+                options: {
+                    ...project.options,
+                    functional: false,
+                    numeric: false,
+                },
+            })(modulo)(expression.arguments?.[0])(
+                type,
+                node.getFullText().trim(),
+            );
+        };
+}

package/src/transformers/features/CreateValidateTransformer.ts

@@ -1,13 +1,13 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateValidateTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createValidateEquals" : "createValidate",
-        )(
-            (project) => (modulo) =>
-                ValidateProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateValidateTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createValidateEquals" : "createValidate",
+        )(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/IsTransformer.ts

@@ -1,11 +1,11 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace IsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "equals" : "is")(
-            (project) => (modulo) =>
-                IsProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace IsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "equals" : "is")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
+        );
+}