typia 5.2.1 → 5.2.2-dev.20231012-2

package/src/Resolved.ts

@@ -1,116 +1,116 @@
-/**
- * Resolved type erased every methods.
- *
- * `Resolved` is a type of TMP (Type Meta Programming) type which converts
- * its argument as a resolved type that erased every method properties.
- *
- * If the target argument is a built-in class which returns its origin primitive type
- * through the `valueOf()` method like the `String` or `Number`, its return type would
- * be the `string` or `number`. Otherwise, the built-in class does not have the
- * `valueOf()` method, the return type would be same with the target argument.
- *
- * Otherwise, the target argument is a type of custom class, all of its custom methods
- * would be erased and its prototype would be changed to the primitive `object`.
- * Therefore, return type of the TMP type finally be the resolved object.
- *
- * Before                  | After
- * ------------------------|----------------------------------------
- * `Boolean`               | `boolean`
- * `Number`                | `number`
- * `BigInt`                | `bigint`
- * `String`                | `string`
- * `Class`                 | `interface`
- * Native Class or Others  | No change
- *
- * @template T Target argument type.
- * @author Jeongho Nam - https://github.com/samchon
- * @author Kyungsu Kang - https://github.com/kakasoo
- */
-export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
-    ? T
-    : ResolvedMain<T>;
-
-type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-
-type ResolvedMain<T> = T extends [never]
-    ? never // (special trick for jsonable | null) type
-    : ValueOf<T> extends boolean | number | bigint | string
-    ? ValueOf<T>
-    : T extends Function
-    ? never
-    : T extends object
-    ? ResolvedObject<T>
-    : ValueOf<T>;
-
-type ResolvedObject<T extends object> = T extends Array<infer U>
-    ? IsTuple<T> extends true
-        ? ResolvedTuple<T>
-        : ResolvedMain<U>[]
-    : T extends Set<infer U>
-    ? Set<ResolvedMain<U>>
-    : T extends Map<infer K, infer V>
-    ? Map<ResolvedMain<K>, ResolvedMain<V>>
-    : T extends WeakSet<any> | WeakMap<any, any>
-    ? never
-    : T extends
-          | Date
-          | Uint8Array
-          | Uint8ClampedArray
-          | Uint16Array
-          | Uint32Array
-          | BigUint64Array
-          | Int8Array
-          | Int16Array
-          | Int32Array
-          | BigInt64Array
-          | Float32Array
-          | Float64Array
-          | ArrayBuffer
-          | SharedArrayBuffer
-          | DataView
-    ? T
-    : {
-          [P in keyof T]: ResolvedMain<T[P]>;
-      };
-
-type ResolvedTuple<T extends readonly any[]> = T extends []
-    ? []
-    : T extends [infer F]
-    ? [ResolvedMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-    ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
-    : T extends [(infer F)?]
-    ? [ResolvedMain<F>?]
-    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-    ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
-    : [];
-
-type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
-    never,
-]
-    ? false
-    : T extends readonly any[]
-    ? number extends T["length"]
-        ? false
-        : true
-    : false;
-
-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;
-}
+/**
+ * Resolved type erased every methods.
+ *
+ * `Resolved` is a type of TMP (Type Meta Programming) type which converts
+ * its argument as a resolved type that erased every method properties.
+ *
+ * If the target argument is a built-in class which returns its origin primitive type
+ * through the `valueOf()` method like the `String` or `Number`, its return type would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be same with the target argument.
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom methods
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the resolved object.
+ *
+ * Before                  | After
+ * ------------------------|----------------------------------------
+ * `Boolean`               | `boolean`
+ * `Number`                | `number`
+ * `BigInt`                | `bigint`
+ * `String`                | `string`
+ * `Class`                 | `interface`
+ * Native Class or Others  | No change
+ *
+ * @template T Target argument type.
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
+    ? T
+    : ResolvedMain<T>;
+
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type ResolvedMain<T> = T extends [never]
+    ? never // (special trick for jsonable | null) type
+    : ValueOf<T> extends boolean | number | bigint | string
+    ? ValueOf<T>
+    : T extends Function
+    ? never
+    : T extends object
+    ? ResolvedObject<T>
+    : ValueOf<T>;
+
+type ResolvedObject<T extends object> = T extends Array<infer U>
+    ? IsTuple<T> extends true
+        ? ResolvedTuple<T>
+        : ResolvedMain<U>[]
+    : T extends Set<infer U>
+    ? Set<ResolvedMain<U>>
+    : T extends Map<infer K, infer V>
+    ? Map<ResolvedMain<K>, ResolvedMain<V>>
+    : T extends WeakSet<any> | WeakMap<any, any>
+    ? never
+    : T extends
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? T
+    : {
+          [P in keyof T]: ResolvedMain<T[P]>;
+      };
+
+type ResolvedTuple<T extends readonly any[]> = T extends []
+    ? []
+    : T extends [infer F]
+    ? [ResolvedMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+    ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
+    : T extends [(infer F)?]
+    ? [ResolvedMain<F>?]
+    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+    ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
+    : [];
+
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+    never,
+]
+    ? false
+    : T extends readonly any[]
+    ? number extends T["length"]
+        ? false
+        : true
+    : false;
+
+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/SnakeCase.ts

@@ -1,156 +1,156 @@
-/**
- * Snake case type.
- *
- * `SnakeCase` type is a type that all keys of an object are converted to snake case.
- *
- * It also erase every method properties like {@link Resolved} type.
- *
- * @template T Target type to be snake cased
- * @author Jeongho Nam - https://github.com/samchon
- */
-export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true
-    ? T
-    : SnakageMain<T>;
-
-/* -----------------------------------------------------------
-    OBJECT CONVERSION
------------------------------------------------------------ */
-type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-
-type SnakageMain<T> = T extends [never]
-    ? never // special trick for (jsonable | null) type
-    : T extends { valueOf(): boolean | bigint | number | string }
-    ? ValueOf<T>
-    : T extends Function
-    ? never
-    : T extends object
-    ? SnakageObject<T>
-    : T;
-
-type SnakageObject<T extends object> = T extends Array<infer U>
-    ? IsTuple<T> extends true
-        ? SnakageTuple<T>
-        : SnakageMain<U>[]
-    : T extends Set<infer U>
-    ? Set<SnakageMain<U>>
-    : T extends Map<infer K, infer V>
-    ? Map<SnakageMain<K>, SnakageMain<V>>
-    : T extends WeakSet<any> | WeakMap<any, any>
-    ? never
-    : T extends
-          | Date
-          | Uint8Array
-          | Uint8ClampedArray
-          | Uint16Array
-          | Uint32Array
-          | BigUint64Array
-          | Int8Array
-          | Int16Array
-          | Int32Array
-          | BigInt64Array
-          | Float32Array
-          | Float64Array
-          | ArrayBuffer
-          | SharedArrayBuffer
-          | DataView
-    ? T
-    : {
-          [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;
-      };
-
-/* -----------------------------------------------------------
-    SPECIAL CASES
------------------------------------------------------------ */
-type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
-    never,
-]
-    ? false
-    : T extends readonly any[]
-    ? number extends T["length"]
-        ? false
-        : true
-    : false;
-type SnakageTuple<T extends readonly any[]> = T extends []
-    ? []
-    : T extends [infer F]
-    ? [SnakageMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-    ? [SnakageMain<F>, ...SnakageTuple<Rest>]
-    : T extends [(infer F)?]
-    ? [SnakageMain<F>?]
-    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-    ? [SnakageMain<F>?, ...SnakageTuple<Rest>]
-    : [];
-
-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;
-}
-
-/* -----------------------------------------------------------
-    STRING CONVERTER
------------------------------------------------------------ */
-type SnakageString<Key extends string> = Key extends `${infer _}`
-    ? SnakageStringRepeatedly<Key, "">
-    : Key;
-type SnakageStringRepeatedly<
-    S extends string,
-    Previous extends string,
-> = S extends `${infer First}${infer Second}${infer Rest}`
-    ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<
-          First,
-          Second
-      >}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}`
-    : S extends `${infer First}`
-    ? `${Underscore<Previous, First>}${Lowercase<First>}`
-    : "";
-type Underscore<First extends string, Second extends string> = First extends
-    | UpperAlphabetic
-    | ""
-    | "_"
-    ? ""
-    : Second extends UpperAlphabetic
-    ? "_"
-    : "";
-type UpperAlphabetic =
-    | "A"
-    | "B"
-    | "C"
-    | "D"
-    | "E"
-    | "F"
-    | "G"
-    | "H"
-    | "I"
-    | "J"
-    | "K"
-    | "L"
-    | "M"
-    | "N"
-    | "O"
-    | "P"
-    | "Q"
-    | "R"
-    | "S"
-    | "T"
-    | "U"
-    | "V"
-    | "W"
-    | "X"
-    | "Y"
-    | "Z";
+/**
+ * Snake case type.
+ *
+ * `SnakeCase` type is a type that all keys of an object are converted to snake case.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be snake cased
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true
+    ? T
+    : SnakageMain<T>;
+
+/* -----------------------------------------------------------
+    OBJECT CONVERSION
+----------------------------------------------------------- */
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type SnakageMain<T> = T extends [never]
+    ? never // special trick for (jsonable | null) type
+    : T extends { valueOf(): boolean | bigint | number | string }
+    ? ValueOf<T>
+    : T extends Function
+    ? never
+    : T extends object
+    ? SnakageObject<T>
+    : T;
+
+type SnakageObject<T extends object> = T extends Array<infer U>
+    ? IsTuple<T> extends true
+        ? SnakageTuple<T>
+        : SnakageMain<U>[]
+    : T extends Set<infer U>
+    ? Set<SnakageMain<U>>
+    : T extends Map<infer K, infer V>
+    ? Map<SnakageMain<K>, SnakageMain<V>>
+    : T extends WeakSet<any> | WeakMap<any, any>
+    ? never
+    : T extends
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? T
+    : {
+          [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;
+      };
+
+/* -----------------------------------------------------------
+    SPECIAL CASES
+----------------------------------------------------------- */
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+    never,
+]
+    ? false
+    : T extends readonly any[]
+    ? number extends T["length"]
+        ? false
+        : true
+    : false;
+type SnakageTuple<T extends readonly any[]> = T extends []
+    ? []
+    : T extends [infer F]
+    ? [SnakageMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+    ? [SnakageMain<F>, ...SnakageTuple<Rest>]
+    : T extends [(infer F)?]
+    ? [SnakageMain<F>?]
+    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+    ? [SnakageMain<F>?, ...SnakageTuple<Rest>]
+    : [];
+
+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;
+}
+
+/* -----------------------------------------------------------
+    STRING CONVERTER
+----------------------------------------------------------- */
+type SnakageString<Key extends string> = Key extends `${infer _}`
+    ? SnakageStringRepeatedly<Key, "">
+    : Key;
+type SnakageStringRepeatedly<
+    S extends string,
+    Previous extends string,
+> = S extends `${infer First}${infer Second}${infer Rest}`
+    ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<
+          First,
+          Second
+      >}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}`
+    : S extends `${infer First}`
+    ? `${Underscore<Previous, First>}${Lowercase<First>}`
+    : "";
+type Underscore<First extends string, Second extends string> = First extends
+    | UpperAlphabetic
+    | ""
+    | "_"
+    ? ""
+    : Second extends UpperAlphabetic
+    ? "_"
+    : "";
+type UpperAlphabetic =
+    | "A"
+    | "B"
+    | "C"
+    | "D"
+    | "E"
+    | "F"
+    | "G"
+    | "H"
+    | "I"
+    | "J"
+    | "K"
+    | "L"
+    | "M"
+    | "N"
+    | "O"
+    | "P"
+    | "Q"
+    | "R"
+    | "S"
+    | "T"
+    | "U"
+    | "V"
+    | "W"
+    | "X"
+    | "Y"
+    | "Z";

package/src/executable/TypiaSetupWizard.ts

@@ -33,8 +33,16 @@ export namespace TypiaSetupWizard {
 
         // SETUP TRANSFORMER
         await pack.save((data) => {
-            // COMPOSE POSTINSTALL COMMAND
+            // COMPOSE PREPARE COMMAND
             data.scripts ??= {};
+            if (
+                typeof data.scripts.prepare === "string" &&
+                data.scripts.prepare.trim().length
+            ) {
+                if (data.scripts.prepare.indexOf("ts-patch install") === -1)
+                    data.scripts.prepare =
+                        "ts-patch install && " + data.scripts.prepare;
+            } else data.scripts.prepare = "ts-patch install";
 
             // FOR OLDER VERSIONS
             if (typeof data.scripts.postinstall === "string") {
@@ -46,16 +54,6 @@ export namespace TypiaSetupWizard {
                 if (data.scripts.postinstall.length === 0)
                     delete data.scripts.postinstall;
             }
-
-            // THE PREPARE SCRIPT
-            if (
-                typeof data.scripts.prepare === "string" &&
-                data.scripts.prepare.trim().length
-            ) {
-                if (data.scripts.prepare.indexOf("ts-patch install") === -1)
-                    data.scripts.prepare =
-                        "ts-patch install && " + data.scripts.prepare;
-            } else data.scripts.prepare = "ts-patch install";
         });
         CommandExecutor.run(`${pack.manager} run prepare`);
 

package/src/factories/JsonMetadataFactory.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { Metadata } from "../schemas/metadata/Metadata";
 
+import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
+
 import { TransformerError } from "../transformers/TransformerError";
 
 import { MetadataCollection } from "./MetadataCollection";
@@ -38,6 +40,11 @@ export namespace JsonMetadataFactory {
             meta.arrays.some((a) => a.type.value.isRequired() === false)
         )
             output.push("JSON does not support undefined type in array.");
+        if (meta.maps.length) output.push("JSON does not support Map type.");
+        if (meta.sets.length) output.push("JSON does not support Set type.");
+        for (const native of meta.natives)
+            if (AtomicPredicator.native(native) === false && native !== "Date")
+                output.push(`JSON does not support ${native} type.`);
         return output;
     };
 }

package/src/factories/MetadataCollection.ts

@@ -117,9 +117,14 @@ export class MetadataCollection {
             name: $id,
             properties: [],
             description:
+                (type.aliasSymbol &&
+                    CommentFactory.description(type.aliasSymbol)) ??
                 (type.symbol && CommentFactory.description(type.symbol)) ??
                 undefined,
-            jsDocTags: type.symbol?.getJsDocTags() ?? [],
+            jsDocTags:
+                type.aliasSymbol?.getJsDocTags() ??
+                type.symbol?.getJsDocTags() ??
+                [],
             validated: false,
             index: this.object_index_++,
             recursive: null!,