typia 6.10.0 → 6.10.1-dev.20240919

package/src/transformers/features/protobuf/ProtobufDecodeTransformer.ts

@@ -1,9 +1,9 @@
-import { ProtobufDecodeProgrammer } from "../../../programmers/protobuf/ProtobufDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufDecodeTransformer {
-  export const transform = GenericTransformer.scalar("protobuf.decode")(
-    (project) => (modulo) => ProtobufDecodeProgrammer.write(project)(modulo),
-  );
-}
+import { ProtobufDecodeProgrammer } from "../../../programmers/protobuf/ProtobufDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufDecodeTransformer {
+  export const transform = GenericTransformer.scalar("protobuf.decode")(
+    (project) => (modulo) => ProtobufDecodeProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/protobuf/ProtobufEncodeTransformer.ts

@@ -1,9 +1,9 @@
-import { ProtobufEncodeProgrammer } from "../../../programmers/protobuf/ProtobufEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufEncodeTransformer {
-  export const transform = GenericTransformer.scalar("protobuf.encode")(
-    (project) => (modulo) => ProtobufEncodeProgrammer.write(project)(modulo),
-  );
-}
+import { ProtobufEncodeProgrammer } from "../../../programmers/protobuf/ProtobufEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufEncodeTransformer {
+  export const transform = GenericTransformer.scalar("protobuf.encode")(
+    (project) => (modulo) => ProtobufEncodeProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/protobuf/ProtobufIsDecodeTransformer.ts

@@ -1,9 +1,9 @@
-import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/ProtobufIsDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufIsDecodeTransformer {
-  export const transform = GenericTransformer.scalar("protobuf.isDecode")(
-    (project) => (modulo) => ProtobufIsDecodeProgrammer.write(project)(modulo),
-  );
-}
+import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/ProtobufIsDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufIsDecodeTransformer {
+  export const transform = GenericTransformer.scalar("protobuf.isDecode")(
+    (project) => (modulo) => ProtobufIsDecodeProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/protobuf/ProtobufIsEncodeTransformer.ts

@@ -1,9 +1,9 @@
-import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/ProtobufIsEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufIsEncodeTransformer {
-  export const transform = GenericTransformer.scalar("protobuf.isEncode")(
-    (project) => (modulo) => ProtobufIsEncodeProgrammer.write(project)(modulo),
-  );
-}
+import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/ProtobufIsEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufIsEncodeTransformer {
+  export const transform = GenericTransformer.scalar("protobuf.isEncode")(
+    (project) => (modulo) => ProtobufIsEncodeProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/protobuf/ProtobufValidateDecodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufValidateDecodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufValidateDecodeTransformer {
-  export const transform = GenericTransformer.scalar("protobuf.validateDecode")(
-    (project) => (modulo) =>
-      ProtobufValidateDecodeProgrammer.write(project)(modulo),
-  );
-}
+import { ProtobufValidateDecodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufValidateDecodeTransformer {
+  export const transform = GenericTransformer.scalar("protobuf.validateDecode")(
+    (project) => (modulo) =>
+      ProtobufValidateDecodeProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/protobuf/ProtobufValidateEncodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufValidateEncodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufValidateEncodeTransformer {
-  export const transform = GenericTransformer.scalar("protobuf.validateEncode")(
-    (project) => (modulo) =>
-      ProtobufValidateEncodeProgrammer.write(project)(modulo),
-  );
-}
+import { ProtobufValidateEncodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufValidateEncodeTransformer {
+  export const transform = GenericTransformer.scalar("protobuf.validateEncode")(
+    (project) => (modulo) =>
+      ProtobufValidateEncodeProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/reflect/ReflectNameTransformer.ts

@@ -1,66 +1,66 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { ValidationPipe } from "../../../typings/ValidationPipe";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace ReflectNameTransformer {
-  export const transform =
-    (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      if (!expression.typeArguments?.length)
-        throw new TransformerError({
-          code: "typia.reflect.metadata",
-          message: "no generic argument.",
-        });
-      const top: ts.Node = expression.typeArguments[0]!;
-      const regular: boolean = (() => {
-        // CHECK SECOND ARGUMENT EXISTENCE
-        const second: ts.Node | undefined = expression.typeArguments[1]!;
-        if (second === undefined) return false;
-
-        // GET BOOELAN VALUE
-        const value: Metadata = getMetadata(project)(second);
-        return value.size() === 1 &&
-          value.constants.length === 1 &&
-          value.constants[0]!.type === "boolean" &&
-          value.constants[0]!.values.length === 1
-          ? (value.constants[0]!.values[0]!.value as boolean)
-          : false;
-      })();
-
-      // RETURNS NAME
-      return ts.factory.createStringLiteral(
-        regular ? getMetadata(project)(top).getName() : top.getFullText(),
-      );
-    };
-}
-
-const getMetadata =
-  (project: IProject) =>
-  (node: ts.Node): Metadata => {
-    const type: ts.Type = project.checker.getTypeFromTypeNode(
-      node as ts.TypeNode,
-    );
-    const collection: MetadataCollection = new MetadataCollection({
-      replace: MetadataCollection.replace,
-    });
-    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-      MetadataFactory.analyze(
-        project.checker,
-        project.context,
-      )({
-        escape: false,
-        constant: true,
-        absorb: false,
-      })(collection)(type);
-    if (result.success === false)
-      throw TransformerError.from("typia.reflect.name")(result.errors);
-    return result.data;
-  };
+import ts from "typescript";
+
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ReflectNameTransformer {
+  export const transform =
+    (project: IProject) =>
+    (expression: ts.CallExpression): ts.Expression => {
+      if (!expression.typeArguments?.length)
+        throw new TransformerError({
+          code: "typia.reflect.metadata",
+          message: "no generic argument.",
+        });
+      const top: ts.Node = expression.typeArguments[0]!;
+      const regular: boolean = (() => {
+        // CHECK SECOND ARGUMENT EXISTENCE
+        const second: ts.Node | undefined = expression.typeArguments[1]!;
+        if (second === undefined) return false;
+
+        // GET BOOELAN VALUE
+        const value: Metadata = getMetadata(project)(second);
+        return value.size() === 1 &&
+          value.constants.length === 1 &&
+          value.constants[0]!.type === "boolean" &&
+          value.constants[0]!.values.length === 1
+          ? (value.constants[0]!.values[0]!.value as boolean)
+          : false;
+      })();
+
+      // RETURNS NAME
+      return ts.factory.createStringLiteral(
+        regular ? getMetadata(project)(top).getName() : top.getFullText(),
+      );
+    };
+}
+
+const getMetadata =
+  (project: IProject) =>
+  (node: ts.Node): Metadata => {
+    const type: ts.Type = project.checker.getTypeFromTypeNode(
+      node as ts.TypeNode,
+    );
+    const collection: MetadataCollection = new MetadataCollection({
+      replace: MetadataCollection.replace,
+    });
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze(
+        project.checker,
+        project.context,
+      )({
+        escape: false,
+        constant: true,
+        absorb: false,
+      })(collection)(type);
+    if (result.success === false)
+      throw TransformerError.from("typia.reflect.name")(result.errors);
+    return result.data;
+  };

package/src/typings/Atomic.ts

@@ -1,13 +1,13 @@
-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/Customizable.ts

@@ -1,5 +1,5 @@
-export type Customizable = {
-  number: number;
-  string: string;
-  bigint: bigint;
-};
+export type Customizable = {
+  number: number;
+  string: string;
+  bigint: bigint;
+};

package/src/typings/Equal.ts

@@ -1,18 +1,18 @@
-/**
- * Compare the equivalence of the two types X and Y.
- *
- * The two types X and Y refer to any type that can be expressed in the type script, such as the union type and the object type.
- *
- * @template X One of the types to compare
- * @template Y One of the types to compare
- *
- * ```ts
- * type Answer = Equal<1 | 2, 1 | 2>; // true
- * ```
- *
- * @author Kyungsu Kang - https://github.com/kakasoo
- */
-export type Equal<X, Y> =
-  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
-    ? true
-    : false;
+/**
+ * Compare the equivalence of the two types X and Y.
+ *
+ * The two types X and Y refer to any type that can be expressed in the type script, such as the union type and the object type.
+ *
+ * @template X One of the types to compare
+ * @template Y One of the types to compare
+ *
+ * ```ts
+ * type Answer = Equal<1 | 2, 1 | 2>; // true
+ * ```
+ *
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Equal<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+    ? true
+    : false;

package/src/typings/IsTuple.ts

@@ -1,9 +1,9 @@
-export type IsTuple<T extends readonly any[] | { length: number }> = [
-  T,
-] extends [never]
-  ? false
-  : T extends readonly any[]
-    ? number extends T["length"]
-      ? false
-      : true
-    : false;
+export type IsTuple<T extends readonly any[] | { length: number }> = [
+  T,
+] extends [never]
+  ? false
+  : T extends readonly any[]
+    ? number extends T["length"]
+      ? false
+      : true
+    : false;

package/src/typings/NativeClass.ts

@@ -1,23 +1,23 @@
-export type NativeClass =
-  | Date
-  | Set<any>
-  | Map<any, any>
-  | WeakSet<any>
-  | WeakMap<any, any>
-  | Uint8Array
-  | Uint8ClampedArray
-  | Uint16Array
-  | Uint32Array
-  | BigUint64Array
-  | Int8Array
-  | Int16Array
-  | Int32Array
-  | BigInt64Array
-  | Float32Array
-  | Float64Array
-  | ArrayBuffer
-  | SharedArrayBuffer
-  | DataView
-  | Blob
-  | File
-  | RegExp;
+export type NativeClass =
+  | Date
+  | Set<any>
+  | Map<any, any>
+  | WeakSet<any>
+  | WeakMap<any, any>
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | BigUint64Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | BigInt64Array
+  | Float32Array
+  | Float64Array
+  | ArrayBuffer
+  | SharedArrayBuffer
+  | DataView
+  | Blob
+  | File
+  | RegExp;

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/ProtobufAtomic.ts

@@ -1,19 +1,19 @@
-export type ProtobufAtomic =
-  | "bool"
-  | "int32"
-  | "uint32"
-  | "int64"
-  | "uint64"
-  | "float"
-  | "double"
-  | "string";
-export namespace ProtobufAtomic {
-  export type Numeric =
-    | "int32"
-    | "uint32"
-    | "int64"
-    | "uint64"
-    | "float"
-    | "double";
-  export type BigNumeric = "int64" | "uint64";
-}
+export type ProtobufAtomic =
+  | "bool"
+  | "int32"
+  | "uint32"
+  | "int64"
+  | "uint64"
+  | "float"
+  | "double"
+  | "string";
+export namespace ProtobufAtomic {
+  export type Numeric =
+    | "int32"
+    | "uint32"
+    | "int64"
+    | "uint64"
+    | "float"
+    | "double";
+  export type BigNumeric = "int64" | "uint64";
+}

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/ValidationPipe.ts

@@ -1,9 +1,9 @@
-export type ValidationPipe<T, E> =
-  | {
-      success: true;
-      data: T;
-    }
-  | {
-      success: false;
-      errors: E[];
-    };
+export type ValidationPipe<T, E> =
+  | {
+      success: true;
+      data: T;
+    }
+  | {
+      success: false;
+      errors: E[];
+    };

package/src/typings/ValueOf.ts

@@ -1,20 +1,20 @@
-export type ValueOf<Instance> =
-  IsValueOf<Instance, Boolean> extends true
-    ? boolean
-    : IsValueOf<Instance, Number> extends true
-      ? number
-      : IsValueOf<Instance, String> extends true
-        ? string
-        : Instance;
-
-type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
-  ? Object extends IValueOf<infer Primitive>
-    ? Instance extends Primitive
-      ? false
-      : true // not Primitive, but Object
-    : false // cannot be
-  : false;
-
-interface IValueOf<T> {
-  valueOf(): T;
-}
+export type ValueOf<Instance> =
+  IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : IsValueOf<Instance, Number> extends true
+      ? number
+      : IsValueOf<Instance, String> extends true
+        ? string
+        : Instance;
+
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
+  ? Object extends IValueOf<infer Primitive>
+    ? Instance extends Primitive
+      ? false
+      : true // not Primitive, but Object
+    : false // cannot be
+  : false;
+
+interface IValueOf<T> {
+  valueOf(): T;
+}

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,41 +1,41 @@
-export namespace ArrayUtil {
-  export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
-    array.some(pred);
-
-  export const add = <T>(
-    array: T[],
-    value: T,
-    pred: (x: T, y: T) => boolean = (x, y) => x === y,
-  ): boolean => {
-    if (array.some((elem) => pred(elem, value))) return false;
-    array.push(value);
-    return true;
-  };
-
-  export const 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 const 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 const repeat = <T>(
-    count: number,
-    closure: (index: number, count: number) => T,
-  ): T[] => new Array(count).fill("").map((_, index) => closure(index, count));
-}
+export namespace ArrayUtil {
+  export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
+    array.some(pred);
+
+  export const add = <T>(
+    array: T[],
+    value: T,
+    pred: (x: T, y: T) => boolean = (x, y) => x === y,
+  ): boolean => {
+    if (array.some((elem) => pred(elem, value))) return false;
+    array.push(value);
+    return true;
+  };
+
+  export const 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 const 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 const repeat = <T>(
+    count: number,
+    closure: (index: number, count: number) => T,
+  ): T[] => new Array(count).fill("").map((_, index) => closure(index, count));
+}