typia 3.8.4 → 4.0.0-dev.20230502

package/src/schemas/IJsonSchema.ts

@@ -1,130 +1,130 @@
-import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../metadata/IMetadataTag";
-
-import { Atomic } from "../typings/Atomic";
-
-export type IJsonSchema = IJsonSchema.Known | IJsonSchema.IUnknown;
-export namespace IJsonSchema {
-    export type Known =
-        | IEnumeration<"boolean">
-        | IEnumeration<"number">
-        | IEnumeration<"string">
-        | IBoolean
-        | IInteger
-        | INumber
-        | IString
-        | IArray
-        | ITuple
-        | IOneOf
-        | IReference
-        | IRecursiveReference
-        | INullOnly;
-
-    export interface IUnknown extends IAttribute {
-        type: undefined;
-    }
-
-    /**
-     * @deprecated Use {@link Known} type instead.
-     */
-    export type NotUnknown = Known;
-
-    /* -----------------------------------------------------------
-        ATOMICS
-    ----------------------------------------------------------- */
-    export interface IEnumeration<
-        Literal extends Exclude<Atomic.Literal, "bigint">,
-    > extends IAtomic<Literal> {
-        enum: Array<Atomic.Mapper[Literal]>;
-    }
-    export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
-        extends ISignificant<Literal> {
-        default?: Atomic.Mapper[Literal];
-    }
-    export interface IString extends IAtomic<"string"> {
-        /**
-         * @type uint
-         */
-        minLength?: number;
-        /**
-         * @type uint
-         */
-        maxLength?: number;
-        pattern?: string;
-        format?: string;
-    }
-    export interface INumber extends IAtomic<"number"> {
-        minimum?: number;
-        maximum?: number;
-        exclusiveMinimum?: boolean;
-        exclusiveMaximum?: boolean;
-        multipleOf?: number;
-    }
-    export interface IInteger extends IAtomic<"integer"> {
-        /**
-         * @type int
-         */
-        minimum?: number;
-        /**
-         * @type int
-         */
-        maximum?: number;
-        exclusiveMinimum?: boolean;
-        exclusiveMaximum?: boolean;
-        /**
-         * @type int
-         */
-        multipleOf?: number;
-    }
-    export interface IBoolean extends IAtomic<"boolean"> {}
-
-    /* -----------------------------------------------------------
-        OBJECTS
-    ----------------------------------------------------------- */
-    export interface IArray extends ISignificant<"array"> {
-        items: IJsonSchema;
-        /**
-         * @type uint
-         */
-        minItems?: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
-        "x-typia-tuple"?: ITuple;
-    }
-    export interface ITuple extends ISignificant<"array"> {
-        items: IJsonSchema[];
-    }
-    export interface IReference extends IAttribute {
-        $ref: string;
-    }
-    export interface IRecursiveReference extends IAttribute {
-        $recursiveRef: string;
-    }
-    export interface INullOnly extends IAttribute {
-        type: "null";
-    }
-
-    /* -----------------------------------------------------------
-        MISCELLANEOUS
-    ----------------------------------------------------------- */
-    export interface IOneOf extends IAttribute {
-        oneOf: IJsonSchema[];
-    }
-
-    export interface ISignificant<Literal extends string> extends IAttribute {
-        type: Literal;
-        nullable: boolean;
-    }
-    export interface IAttribute {
-        deprecated?: boolean;
-        title?: string;
-        description?: string;
-        "x-typia-metaTags"?: IMetadataTag[];
-        "x-typia-jsDocTags"?: IJsDocTagInfo[];
-        "x-typia-required"?: boolean;
-        "x-typia-optional"?: boolean;
-        "x-typia-rest"?: boolean;
-    }
-}
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../metadata/IMetadataTag";
+
+import { Atomic } from "../typings/Atomic";
+
+export type IJsonSchema = IJsonSchema.Known | IJsonSchema.IUnknown;
+export namespace IJsonSchema {
+    export type Known =
+        | IEnumeration<"boolean">
+        | IEnumeration<"number">
+        | IEnumeration<"string">
+        | IBoolean
+        | IInteger
+        | INumber
+        | IString
+        | IArray
+        | ITuple
+        | IOneOf
+        | IReference
+        | IRecursiveReference
+        | INullOnly;
+
+    export interface IUnknown extends IAttribute {
+        type: undefined;
+    }
+
+    /**
+     * @deprecated Use {@link Known} type instead.
+     */
+    export type NotUnknown = Known;
+
+    /* -----------------------------------------------------------
+        ATOMICS
+    ----------------------------------------------------------- */
+    export interface IEnumeration<
+        Literal extends Exclude<Atomic.Literal, "bigint">,
+    > extends IAtomic<Literal> {
+        enum: Array<Atomic.Mapper[Literal]>;
+    }
+    export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
+        extends ISignificant<Literal> {
+        default?: Atomic.Mapper[Literal];
+    }
+    export interface IString extends IAtomic<"string"> {
+        /**
+         * @type uint
+         */
+        minLength?: number;
+        /**
+         * @type uint
+         */
+        maxLength?: number;
+        pattern?: string;
+        format?: string;
+    }
+    export interface INumber extends IAtomic<"number"> {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
+        multipleOf?: number;
+    }
+    export interface IInteger extends IAtomic<"integer"> {
+        /**
+         * @type int
+         */
+        minimum?: number;
+        /**
+         * @type int
+         */
+        maximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
+        /**
+         * @type int
+         */
+        multipleOf?: number;
+    }
+    export interface IBoolean extends IAtomic<"boolean"> {}
+
+    /* -----------------------------------------------------------
+        OBJECTS
+    ----------------------------------------------------------- */
+    export interface IArray extends ISignificant<"array"> {
+        items: IJsonSchema;
+        /**
+         * @type uint
+         */
+        minItems?: number;
+        /**
+         * @type uint
+         */
+        maxItems?: number;
+        "x-typia-tuple"?: ITuple;
+    }
+    export interface ITuple extends ISignificant<"array"> {
+        items: IJsonSchema[];
+    }
+    export interface IReference extends IAttribute {
+        $ref: string;
+    }
+    export interface IRecursiveReference extends IAttribute {
+        $recursiveRef: string;
+    }
+    export interface INullOnly extends IAttribute {
+        type: "null";
+    }
+
+    /* -----------------------------------------------------------
+        MISCELLANEOUS
+    ----------------------------------------------------------- */
+    export interface IOneOf extends IAttribute {
+        oneOf: IJsonSchema[];
+    }
+
+    export interface ISignificant<Literal extends string> extends IAttribute {
+        type: Literal;
+        nullable: boolean;
+    }
+    export interface IAttribute {
+        deprecated?: boolean;
+        title?: string;
+        description?: string;
+        "x-typia-metaTags"?: IMetadataTag[];
+        "x-typia-jsDocTags"?: IJsDocTagInfo[];
+        "x-typia-required"?: boolean;
+        "x-typia-optional"?: boolean;
+        "x-typia-rest"?: boolean;
+    }
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -29,6 +29,7 @@ import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransf
 import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
 import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
 import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
+import { MessageTransformer } from "./features/protocols/MessageTransformer";
 import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
 import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
 import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
@@ -97,7 +98,7 @@ const CLI_PATH = path.resolve(
 
 const FUNCTORS: Record<string, () => Task> = {
     //----
-    // SINGLE FUNCTIONS
+    // VALIDATORS
     //----
     // BASIC VALIDATORS
     assert: () => AssertTransformer.transform(false),
@@ -110,14 +111,24 @@ const FUNCTORS: Record<string, () => Task> = {
     equals: () => IsTransformer.transform(true),
     validateEquals: () => ValidateTransformer.transform(true),
 
-    // PARSE FUNCTIONS
+    //----
+    // PROTOCOL BUFFER
+    //----
+    message: () => MessageTransformer.transform,
+
+    //----
+    // JSON FUNCTIONS
+    //----
+    // SCHEMA DEFINITION
+    application: () => (project) => () =>
+        ApplicationTransformer.transform(project),
+
+    // PARSER FUNCTIONS
     isParse: () => IsParseTransformer.transform,
     assertParse: () => AssertParseTransformer.transform,
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
-    application: () => (project) => () =>
-        ApplicationTransformer.transform(project),
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
@@ -141,23 +152,19 @@ const FUNCTORS: Record<string, () => Task> = {
     //----
     // FACTORY FUNCTIONS
     //----
-    // BASIC VALIDATORS
+    // VALIDATORS
     createAssert: () => CreateAssertTransformer.transform(false),
     createAssertType: () => CreateAssertTransformer.transform(false),
     createIs: () => CreateIsTransformer.transform(false),
     createValidate: () => CreateValidateTransformer.transform(false),
-
-    // STRICT VALIDATORS
     createAssertEquals: () => CreateAssertTransformer.transform(true),
     createEquals: () => CreateIsTransformer.transform(true),
     createValidateEquals: () => CreateValidateTransformer.transform(true),
 
-    // PARSE FUNCTIONS
+    // JSON FUNCTIONS
     createIsParse: () => CreateIsParseTransformer.transform,
     createAssertParse: () => CreateAssertParseTransformer.transform,
     createValidateParse: () => CreateValidateParseTransformer.transform,
-
-    // STRINGIFY FUNCTIONS
     createStringify: () => CreateStringifyTransformer.transform,
     createAssertStringify: () => CreateAssertStringifyTransformer.transform,
     createIsStringify: () => CreateIsStringifyTransformer.transform,

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -57,9 +57,7 @@ export namespace ApplicationTransformer {
             // GENERATORS
             //----
             // METADATA
-            const collection: MetadataCollection = new MetadataCollection({
-                replace: MetadataCollection.replace,
-            });
+            const collection: MetadataCollection = new MetadataCollection();
             const metadatas: Array<Metadata> = types.map((type) =>
                 MetadataFactory.analyze(checker)({
                     resolve: true,

package/src/transformers/features/protocols/MessageTransformer.ts

@@ -0,0 +1,31 @@
+import ts from "typescript";
+
+import { MessageProgrammer } from "../../../programmers/MessageProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace MessageTransformer {
+    export const transform =
+        (project: IProject) =>
+        (_modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments || !expression.typeArguments[0])
+                throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+            // GET TYPE INFO
+            const type: ts.Type = project.checker.getTypeFromTypeNode(
+                expression.typeArguments[0],
+            );
+            if (type.isTypeParameter())
+                throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return MessageProgrammer.generate(project)(type);
+        };
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.message(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.message(): non-specified generic argument.",
+}

package/src/utils/NameEncoder.ts

@@ -0,0 +1,32 @@
+export namespace NameEncoder {
+    export function encode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    }
+
+    export function decode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            if (after !== "") str = str.split(after).join(before);
+        return str;
+    }
+}
+
+const REPLACERS: [string, string][] = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["(", "_lp_"],
+    [")", "_rp_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];