typia 7.0.0-dev.20241007 → 7.0.0-dev.20241008

package/src/transformers/TransformerError.ts

@@ -1,59 +1,59 @@
-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 = (props: {
-    code: string;
-    errors: MetadataFactory.IError[];
-  }): TransformerError => {
-    const body: string = props.errors
-      .map((e) => {
-        const subject: string =
-          e.explore.object === null
-            ? ""
-            : join(e.explore.object)(e.explore.property);
-        const middle: string = e.explore.parameter
-          ? `(parameter: ${JSON.stringify(e.explore.parameter)})`
-          : e.explore.output
-            ? "(return type)"
-            : "";
-        const type: string = `${subject.length ? `${subject}: ` : ""}${e.name}`;
-        return `- ${type}${middle}\n${e.messages
-          .map((msg) => `  - ${msg}`)
-          .join("\n")}`;
-      })
-      .join("\n\n");
-    return new TransformerError({
-      code: props.code,
-      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 = (props: {
+    code: string;
+    errors: MetadataFactory.IError[];
+  }): TransformerError => {
+    const body: string = props.errors
+      .map((e) => {
+        const subject: string =
+          e.explore.object === null
+            ? ""
+            : join(e.explore.object)(e.explore.property);
+        const middle: string = e.explore.parameter
+          ? `(parameter: ${JSON.stringify(e.explore.parameter)})`
+          : e.explore.output
+            ? "(return type)"
+            : "";
+        const type: string = `${subject.length ? `${subject}: ` : ""}${e.name}`;
+        return `- ${type}${middle}\n${e.messages
+          .map((msg) => `  - ${msg}`)
+          .join("\n")}`;
+      })
+      .join("\n\n");
+    return new TransformerError({
+      code: props.code,
+      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,24 +1,24 @@
-import { AssertProgrammer } from "../../programmers/AssertProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace AssertTransformer {
-  export const transform =
-    (config: AssertProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.scalar({
-        ...props,
-        method: config.equals
-          ? config.guard
-            ? "assertGuardEquals"
-            : "assertEquals"
-          : config.guard
-            ? "assertGuard"
-            : "assert",
-        write: (x) =>
-          AssertProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace AssertTransformer {
+  export const transform =
+    (config: AssertProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals
+          ? config.guard
+            ? "assertGuardEquals"
+            : "assertEquals"
+          : config.guard
+            ? "assertGuard"
+            : "assert",
+        write: (x) =>
+          AssertProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/CreateAssertTransformer.ts

@@ -1,24 +1,24 @@
-import { AssertProgrammer } from "../../programmers/AssertProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateAssertTransformer {
-  export const transform =
-    (config: AssertProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.factory({
-        ...props,
-        method: config.equals
-          ? config.guard
-            ? "assertGuardEquals"
-            : "assertEquals"
-          : config.guard
-            ? "assertGuard"
-            : "assert",
-        write: (x) =>
-          AssertProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateAssertTransformer {
+  export const transform =
+    (config: AssertProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: config.equals
+          ? config.guard
+            ? "assertGuardEquals"
+            : "assertEquals"
+          : config.guard
+            ? "assertGuard"
+            : "assert",
+        write: (x) =>
+          AssertProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/CreateIsTransformer.ts

@@ -1,18 +1,18 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateIsTransformer {
-  export const transform =
-    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.factory({
-        ...props,
-        method: config.equals ? "equals" : "is",
-        write: (x) =>
-          IsProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateIsTransformer {
+  export const transform =
+    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: config.equals ? "equals" : "is",
+        write: (x) =>
+          IsProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/CreateRandomTransformer.ts

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

package/src/transformers/features/CreateValidateTransformer.ts

@@ -1,18 +1,18 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateValidateTransformer {
-  export const transform =
-    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.factory({
-        ...props,
-        method: config.equals ? "validateEquals" : "validate",
-        write: (x) =>
-          ValidateProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateValidateTransformer {
+  export const transform =
+    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: config.equals ? "validateEquals" : "validate",
+        write: (x) =>
+          ValidateProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/IsTransformer.ts

@@ -1,18 +1,18 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace IsTransformer {
-  export const transform =
-    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.scalar({
-        ...props,
-        method: config.equals ? "equals" : "is",
-        write: (x) =>
-          IsProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace IsTransformer {
+  export const transform =
+    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "equals" : "is",
+        write: (x) =>
+          IsProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/RandomTransformer.ts

@@ -1,41 +1,41 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../programmers/RandomProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { TransformerError } from "../TransformerError";
-
-export namespace RandomTransformer {
-  export const transform = (props: ITransformProps): ts.Expression => {
-    // CHECK GENERIC ARGUMENT EXISTENCE
-    if (!props.expression.typeArguments?.[0])
-      throw new TransformerError({
-        code: `typia.${props.modulo.getText()}`,
-        message: "generic argument is not specified.",
-      });
-
-    // GET TYPE INFO
-    const node: ts.TypeNode = props.expression.typeArguments[0];
-    const type: ts.Type = props.context.checker.getTypeFromTypeNode(node);
-
-    if (type.isTypeParameter())
-      throw new TransformerError({
-        code: `typia.${props.modulo.getText()}`,
-        message: "non-specified generic argument.",
-      });
-
-    return ts.factory.createCallExpression(
-      RandomProgrammer.write({
-        context: props.context,
-        modulo: props.modulo,
-        type,
-        name: node.getFullText().trim(),
-        init: undefined,
-      }),
-      undefined,
-      props.expression.arguments.length
-        ? [props.expression.arguments[0]!]
-        : undefined,
-    );
-  };
-}
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../programmers/RandomProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { TransformerError } from "../TransformerError";
+
+export namespace RandomTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments?.[0])
+      throw new TransformerError({
+        code: `typia.${props.modulo.getText()}`,
+        message: "generic argument is not specified.",
+      });
+
+    // GET TYPE INFO
+    const node: ts.TypeNode = props.expression.typeArguments[0];
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(node);
+
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: `typia.${props.modulo.getText()}`,
+        message: "non-specified generic argument.",
+      });
+
+    return ts.factory.createCallExpression(
+      RandomProgrammer.write({
+        context: props.context,
+        modulo: props.modulo,
+        type,
+        name: node.getFullText().trim(),
+        init: undefined,
+      }),
+      undefined,
+      props.expression.arguments.length
+        ? [props.expression.arguments[0]!]
+        : undefined,
+    );
+  };
+}

package/src/transformers/features/ValidateTransformer.ts

@@ -1,18 +1,18 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace ValidateTransformer {
-  export const transform =
-    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.scalar({
-        ...props,
-        method: config.equals ? "validateEquals" : "validate",
-        write: (x) =>
-          ValidateProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace ValidateTransformer {
+  export const transform =
+    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "validateEquals" : "validate",
+        write: (x) =>
+          ValidateProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/functional/FunctionalGenericTransformer.ts

@@ -1,57 +1,57 @@
-import ts from "typescript";
-
-import { TypeFactory } from "../../../factories/TypeFactory";
-
-import { ITransformProps } from "../../ITransformProps";
-import { ITypiaContext } from "../../ITypiaContext";
-import { TransformerError } from "../../TransformerError";
-
-export namespace FunctionalGenericTransformer {
-  export interface IConfig {
-    equals: boolean;
-  }
-  export interface ISpecification {
-    method: string;
-    config: IConfig;
-    programmer: (p: {
-      context: ITypiaContext;
-      modulo: ts.LeftHandSideExpression;
-      expression: ts.Expression;
-      declaration: ts.FunctionDeclaration;
-      config: IConfig;
-      init?: ts.Expression;
-    }) => ts.Expression;
-  }
-  export const transform =
-    (spec: ISpecification) =>
-    (props: ITransformProps): ts.Expression => {
-      // CHECK PARAMETER
-      if (props.expression.arguments.length === 0)
-        throw new TransformerError({
-          code: `typia.functional.${spec.method}`,
-          message: `no input value.`,
-        });
-
-      // GET TYPE INFO
-      const type: ts.Type =
-        props.expression.typeArguments && props.expression.typeArguments[0]
-          ? props.context.checker.getTypeFromTypeNode(
-              props.expression.typeArguments[0],
-            )
-          : props.context.checker.getTypeAtLocation(
-              props.expression.arguments[0]!,
-            );
-      if (TypeFactory.isFunction(type) === false)
-        throw new TransformerError({
-          code: `typia.functional.${spec.method}`,
-          message: `input value is not a function.`,
-        });
-      return spec.programmer({
-        ...props,
-        config: spec.config,
-        expression: props.expression.arguments[0] as ts.Expression,
-        declaration: type.symbol!.declarations![0] as ts.FunctionDeclaration,
-        init: props.expression.arguments[1],
-      });
-    };
-}
+import ts from "typescript";
+
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+import { ITransformProps } from "../../ITransformProps";
+import { ITypiaContext } from "../../ITypiaContext";
+import { TransformerError } from "../../TransformerError";
+
+export namespace FunctionalGenericTransformer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface ISpecification {
+    method: string;
+    config: IConfig;
+    programmer: (p: {
+      context: ITypiaContext;
+      modulo: ts.LeftHandSideExpression;
+      expression: ts.Expression;
+      declaration: ts.FunctionDeclaration;
+      config: IConfig;
+      init?: ts.Expression;
+    }) => ts.Expression;
+  }
+  export const transform =
+    (spec: ISpecification) =>
+    (props: ITransformProps): ts.Expression => {
+      // CHECK PARAMETER
+      if (props.expression.arguments.length === 0)
+        throw new TransformerError({
+          code: `typia.functional.${spec.method}`,
+          message: `no input value.`,
+        });
+
+      // GET TYPE INFO
+      const type: ts.Type =
+        props.expression.typeArguments && props.expression.typeArguments[0]
+          ? props.context.checker.getTypeFromTypeNode(
+              props.expression.typeArguments[0],
+            )
+          : props.context.checker.getTypeAtLocation(
+              props.expression.arguments[0]!,
+            );
+      if (TypeFactory.isFunction(type) === false)
+        throw new TransformerError({
+          code: `typia.functional.${spec.method}`,
+          message: `input value is not a function.`,
+        });
+      return spec.programmer({
+        ...props,
+        config: spec.config,
+        expression: props.expression.arguments[0] as ts.Expression,
+        declaration: type.symbol!.declarations![0] as ts.FunctionDeclaration,
+        init: props.expression.arguments[1],
+      });
+    };
+}