typia 5.0.0-dev.2023084 → 5.0.0

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 Claas or Others  | No change
- *
- * @template Instance Target argument type.
- * @author Jenogho 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<Instance> = Instance extends [never]
-    ? never // (special trick for jsonable | null) type
-    : ValueOf<Instance> extends boolean | number | bigint | string
-    ? ValueOf<Instance>
-    : Instance extends Function
-    ? never
-    : Instance extends object
-    ? ResolvedObject<Instance>
-    : ValueOf<Instance>;
-
-type ResolvedObject<Instance extends object> = Instance extends Array<infer T>
-    ? IsTuple<Instance> extends true
-        ? ResolvedTuple<Instance>
-        : ResolvedMain<T>[]
-    : Instance extends Set<infer U>
-    ? Set<ResolvedMain<U>>
-    : Instance extends Map<infer K, infer V>
-    ? Map<ResolvedMain<K>, ResolvedMain<V>>
-    : Instance extends WeakSet<any> | WeakMap<any, any>
-    ? never
-    : Instance extends
-          | Date
-          | Uint8Array
-          | Uint8ClampedArray
-          | Uint16Array
-          | Uint32Array
-          | BigUint64Array
-          | Int8Array
-          | Int16Array
-          | Int32Array
-          | BigInt64Array
-          | Float32Array
-          | Float64Array
-          | ArrayBuffer
-          | SharedArrayBuffer
-          | DataView
-    ? Instance
-    : {
-          [P in keyof Instance]: ResolvedMain<Instance[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 ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
-    ? boolean
-    : IsValueOf<Instance, Number> extends true
-    ? number
-    : IsValueOf<Instance, String> extends true
-    ? string
-    : Instance;
-
-type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
-    never,
-]
-    ? false
-    : T extends readonly any[]
-    ? number extends T["length"]
-        ? false
-        : true
-    : false;
-
-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 Instance Target argument type.
+ * @author Jenogho 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<Instance> = Instance extends [never]
+    ? never // (special trick for jsonable | null) type
+    : ValueOf<Instance> extends boolean | number | bigint | string
+    ? ValueOf<Instance>
+    : Instance extends Function
+    ? never
+    : Instance extends object
+    ? ResolvedObject<Instance>
+    : ValueOf<Instance>;
+
+type ResolvedObject<Instance extends object> = Instance extends Array<infer T>
+    ? IsTuple<Instance> extends true
+        ? ResolvedTuple<Instance>
+        : ResolvedMain<T>[]
+    : Instance extends Set<infer U>
+    ? Set<ResolvedMain<U>>
+    : Instance extends Map<infer K, infer V>
+    ? Map<ResolvedMain<K>, ResolvedMain<V>>
+    : Instance extends WeakSet<any> | WeakMap<any, any>
+    ? never
+    : Instance extends
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? Instance
+    : {
+          [P in keyof Instance]: ResolvedMain<Instance[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 ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : IsValueOf<Instance, Number> extends true
+    ? number
+    : IsValueOf<Instance, String> extends true
+    ? string
+    : Instance;
+
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+    never,
+]
+    ? false
+    : T extends readonly any[]
+    ? number extends T["length"]
+        ? false
+        : true
+    : false;
+
+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/executable/TypiaGenerateWizard.ts

@@ -64,7 +64,7 @@ export namespace TypiaGenerateWizard {
                     str.substring(str.length - 5) === ".json",
             );
             if (files.length === 0)
-                throw new Error(`Unable to find "tsconfig.json" file.`);
+                throw new URIError(`Unable to find "tsconfig.json" file.`);
             else if (files.length === 1) return files[0];
             return select("tsconfig")("TS Config File")(files);
         };

package/src/executable/TypiaSetupWizard.ts

@@ -126,7 +126,7 @@ export namespace TypiaSetupWizard {
                 );
             if (fileList.length === 0) {
                 if (process.cwd() !== pack.directory)
-                    throw new Error(`Unable to find "tsconfig.json" file.`);
+                    throw new URIError(`Unable to find "tsconfig.json" file.`);
                 return null;
             } else if (fileList.length === 1) return fileList[0];
             return select("tsconfig")("TS Config File")(fileList);

package/src/executable/setup/PackageManager.ts

@@ -15,7 +15,7 @@ export class PackageManager {
             "package.json",
         )(process.cwd());
         if (location === null)
-            throw new Error(`Unable to find "package.json" file`);
+            throw new URIError(`Unable to find "package.json" file`);
 
         return new PackageManager(
             location,

package/src/executable/setup/PluginConfigurator.ts

@@ -15,7 +15,7 @@ export namespace PluginConfigurator {
             | comments.CommentObject
             | undefined;
         if (compilerOptions === undefined)
-            throw new Error(
+            throw new ReferenceError(
                 `${args.project} file does not have "compilerOptions" property.`,
             );
 
@@ -27,7 +27,7 @@ export namespace PluginConfigurator {
             if (plugins === undefined)
                 return (compilerOptions.plugins = [] as any);
             else if (!Array.isArray(plugins))
-                throw new Error(
+                throw new TypeError(
                     `"plugins" property of ${args.project} must be array type.`,
                 );
             return plugins;

package/src/factories/ExpressionFactory.ts

@@ -1,11 +1,13 @@
 import ts from "typescript";
 
+import { RandomGenerator } from "../utils/RandomGenerator";
+
 export namespace ExpressionFactory {
-    export const bigint = (value: number) =>
+    export const bigint = (value: number | bigint) =>
         ts.factory.createCallExpression(
             ts.factory.createIdentifier("BigInt"),
             undefined,
-            [ts.factory.createNumericLiteral(value)],
+            [ts.factory.createIdentifier(value.toString())],
         );
 
     export const isRequired = (input: ts.Expression): ts.Expression =>
@@ -112,4 +114,46 @@ export namespace ExpressionFactory {
                   undefined,
                   undefined,
               );
+
+    export const getEscapedText =
+        (printer: ts.Printer) =>
+        (input: ts.Expression): string =>
+            printer.printNode(
+                ts.EmitHint.Expression,
+                input,
+                input.getSourceFile(),
+            );
+
+    export const transpile =
+        (context: ts.TransformationContext) =>
+        (script: string) =>
+        (input: ts.Expression): ts.Expression => {
+            const file: ts.SourceFile = ts.createSourceFile(
+                `${RandomGenerator.uuid()}.ts`,
+                script,
+                ts.ScriptTarget.ESNext,
+                true,
+                ts.ScriptKind.TS,
+            );
+            const statement: ts.Statement | undefined = file.statements[0];
+            if (statement === undefined)
+                throw new ReferenceError(
+                    "Error on ExpressionFactory.transpile(): no statement exists.",
+                );
+            else if (!ts.isExpressionStatement(statement))
+                throw new TypeError(
+                    "Error on ExpressionFactory.transpile(): statement is not an expression statement.",
+                );
+
+            const visitor = (node: ts.Node): ts.Node => {
+                if (ts.isIdentifier(node) && node.text === "$input")
+                    return input;
+                return ts.visitEachChild(
+                    (ts.factory as any).cloneNode(node),
+                    visitor,
+                    context,
+                );
+            };
+            return visitor(statement.expression) as ts.Expression;
+        };
 }

package/src/factories/IdentifierFactory.ts

@@ -17,6 +17,21 @@ export namespace IdentifierFactory {
             : ts.factory.createPropertyAccessExpression(target, postfix);
     };
 
+    export const getName = (input: ts.Expression): string => {
+        const value: any = (input as any).escapedText?.toString();
+        if (typeof value === "string") return value;
+
+        if (ts.isPropertyAccessExpression(input))
+            return `${getName(
+                input.expression,
+            )}.${input.name.escapedText.toString()}`;
+        else if (ts.isElementAccessExpression(input))
+            return `${getName(input.expression)}[${getName(
+                input.argumentExpression,
+            )}]`;
+        return "uknown";
+    };
+
     export const postfix = (str: string): string =>
         Escaper.variable(str)
             ? `".${str}"`

package/src/factories/JsonMetadataFactory.ts

@@ -0,0 +1,43 @@
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+
+import { TransformerError } from "../transformers/TransformerError";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+
+export namespace JsonMetadataFactory {
+    export const analyze =
+        (method: string) =>
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type): [MetadataCollection, Metadata] => {
+            const collection = new MetadataCollection();
+            const result = MetadataFactory.analyze(checker)({
+                escape: true,
+                constant: true,
+                absorb: true,
+                validate,
+            })(collection)(type);
+            if (result.success === false)
+                throw TransformerError.from(method)(result.errors);
+            return [collection, result.data];
+        };
+
+    export const validate = (meta: Metadata) => {
+        const output: string[] = [];
+        if (
+            meta.atomics.some((a) => a.type === "bigint") ||
+            meta.constants.some((c) => c.type === "bigint")
+        )
+            output.push("JSON does not support bigint type.");
+        if (
+            meta.tuples.some((t) =>
+                t.type.elements.some((e) => e.isRequired() === false),
+            ) ||
+            meta.arrays.some((a) => a.type.value.isRequired() === false)
+        )
+            output.push("JSON does not support undefined type in array.");
+        return output;
+    };
+}

package/src/factories/LiteralFactory.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { ExpressionFactory } from "./ExpressionFactory";
 import { IdentifierFactory } from "./IdentifierFactory";
 
 export namespace LiteralFactory {
@@ -11,8 +12,12 @@ export namespace LiteralFactory {
         else if (typeof input === "string") return generate_string(input);
         else if (typeof input === "boolean") return generate_value(input);
         else if (typeof input === "number") return generate_value(input);
-        else if (typeof input === "bigint") return generate_value(input);
-        else throw new Error("Unknown type.");
+        else if (typeof input === "bigint") return generate_bigint(input);
+        // unreachable code
+        else
+            throw new TypeError(
+                "Error on LiteralFactory.generate(): unknown type.",
+            );
     };
 
     const generate_object = (obj: object): ts.ObjectLiteralExpression =>
@@ -31,9 +36,12 @@ export namespace LiteralFactory {
     const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
         ts.factory.createArrayLiteralExpression(array.map(generate), true);
 
-    const generate_value = (value: number | boolean | bigint): ts.Identifier =>
+    const generate_value = (value: number | boolean | bigint): ts.Expression =>
         ts.factory.createIdentifier(value.toString());
 
+    const generate_bigint = (value: bigint): ts.Expression =>
+        ExpressionFactory.bigint(value);
+
     const generate_string = (value: string): ts.StringLiteral =>
         ts.factory.createStringLiteral(value);
 }

package/src/factories/MetadataCollection.ts

@@ -3,9 +3,9 @@ import ts from "typescript";
 import { IMetadataCollection } from "../schemas/metadata/IMetadataCollection";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
-import { MetadataArray } from "../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
-import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
 import { Writable } from "../typings/Writable";
 
@@ -18,19 +18,14 @@ export class MetadataCollection {
     private readonly objects_: Map<ts.Type, MetadataObject>;
     private readonly object_unions_: Map<string, MetadataObject[]>;
     private readonly aliases_: Map<ts.Type, MetadataAlias>;
-    private readonly arrays_: Map<ts.Type, MetadataArray>;
-    private readonly tuples_: Map<ts.Type, MetadataTuple>;
+    private readonly arrays_: Map<ts.Type, MetadataArrayType>;
+    private readonly tuples_: Map<ts.Type, MetadataTupleType>;
 
     private readonly names_: Map<string, Map<ts.Type, string>>;
     private object_index_: number;
     private recursive_array_index_: number;
     private recursive_tuple_index_: number;
 
-    /**
-     * @internal
-     */
-    public readonly entire_: Set<Metadata> = new Set();
-
     public constructor(
         private readonly options?: Partial<MetadataCollection.IOptions>,
     ) {
@@ -61,11 +56,11 @@ export class MetadataCollection {
         return [...this.object_unions_.values()];
     }
 
-    public arrays(): MetadataArray[] {
+    public arrays(): MetadataArrayType[] {
         return [...this.arrays_.values()];
     }
 
-    public tuples(): MetadataTuple[] {
+    public tuples(): MetadataTupleType[] {
         return [...this.tuples_.values()];
     }
 
@@ -149,7 +144,6 @@ export class MetadataCollection {
             description: CommentFactory.description(symbol) ?? null,
             recursive: null!,
             nullables: [],
-            tags: [],
             jsDocTags: symbol.getJsDocTags() ?? [],
         });
         this.aliases_.set(type, alias);
@@ -159,12 +153,12 @@ export class MetadataCollection {
     public emplaceArray(
         checker: ts.TypeChecker,
         type: ts.Type,
-    ): [MetadataArray, boolean, (meta: Metadata) => void] {
+    ): [MetadataArrayType, boolean, (meta: Metadata) => void] {
         const oldbie = this.arrays_.get(type);
         if (oldbie !== undefined) return [oldbie, false, () => {}];
 
         const $id = this.getName(checker, type);
-        const array: MetadataArray = MetadataArray.create({
+        const array: MetadataArrayType = MetadataArrayType.create({
             name: $id,
             value: null!,
             index: null,
@@ -178,12 +172,12 @@ export class MetadataCollection {
     public emplaceTuple(
         checker: ts.TypeChecker,
         type: ts.TupleType,
-    ): [MetadataTuple, boolean, (elements: Metadata[]) => void] {
+    ): [MetadataTupleType, boolean, (elements: Metadata[]) => void] {
         const oldbie = this.tuples_.get(type);
         if (oldbie !== undefined) return [oldbie, false, () => {}];
 
         const $id = this.getName(checker, type);
-        const tuple: MetadataTuple = MetadataTuple.create({
+        const tuple: MetadataTupleType = MetadataTupleType.create({
             name: $id,
             elements: null!,
             index: null,
@@ -215,12 +209,18 @@ export class MetadataCollection {
     /**
      * @internal
      */
-    public setArrayRecursive(array: MetadataArray, recursive: boolean): void {
+    public setArrayRecursive(
+        array: MetadataArrayType,
+        recursive: boolean,
+    ): void {
         Writable(array).recursive = recursive;
         if (recursive) Writable(array).index = this.recursive_array_index_++;
     }
 
-    public setTupleRecursive(tuple: MetadataTuple, recursive: boolean): void {
+    public setTupleRecursive(
+        tuple: MetadataTupleType,
+        recursive: boolean,
+    ): void {
         Writable(tuple).recursive = recursive;
         if (recursive) Writable(tuple).index = this.recursive_tuple_index_++;
     }