typia 5.0.0-dev.20230810 → 5.0.0-dev.20230814

package/src/factories/ProtobufFactory.ts

@@ -2,12 +2,11 @@ import ts from "typescript";
 
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
-import { IProtocolMessage } from "../schemas/protobuf/IProtocolMessage";
+
+import { Escaper } from "../utils/Escaper";
 
 import { MetadataCollection } from "./MetadataCollection";
 import { MetadataFactory } from "./MetadataFactory";
-import { emplace_protocol_object } from "./internal/protocols/emplace_protocol_object";
-import { iterate_protocol_main } from "./internal/protocols/iterate_protocol_main";
 
 export namespace ProtobufFactory {
     export const metadata =
@@ -42,37 +41,70 @@ export namespace ProtobufFactory {
             return top;
         };
 
-    export const analyze =
-        (collection: MetadataCollection) =>
-        (dict: Map<string, IProtocolMessage>) =>
-        (meta: Metadata) => {
-            // EMPLACE OBJECTS
-            for (const obj of collection.objects())
-                emplace_protocol_object(dict)(obj);
-
-            // WHEN NOT OBJECT, WRAP IT INTO A FAKE MAIN OBJECT
-            iterate_protocol_main(dict)(meta);
-        };
-
     const validate = (method: string) => (meta: Metadata) => {
         //----
-        // NOT ALLOWED TYPES
+        // NOT SUPPORTED TYPES
         //----
+        // PROHIBIT ANY TYPE
         if (meta.any) throw notSupportedError({ method })("any type");
+        // PROHIBIT FUNCTIONAL TYPE
         else if (meta.functional)
             throw notSupportedError({ method })("functional type");
+        // PROHIBIT TUPLE TYPE
         else if (meta.tuples.length)
             throw notSupportedError({ method })("tuple type");
+        // PROHIBIT SET TYPE
         else if (meta.sets.length)
             throw notSupportedError({ method })("Set type");
+        // NATIVE TYPE, BUT NOT Uint8Array
+        else if (meta.natives.length) {
+            const banned = meta.natives
+                .map((n) => [n, BANNED_NATIVE_TYPES.get(n)] as const)
+                .filter(([_n, b]) => b !== undefined)[0];
+            if (banned !== undefined)
+                throw notSupportedError({ method })(
+                    banned[1] === null
+                        ? banned[0]
+                        : `${banned[0]}. Use ${banned[1]} instead.`,
+                );
+        }
+        //----
+        // ARRRAY CASES
+        //----
+        // DO NOT ALLOW MULTI-DIMENTIONAL ARRAY
         else if (
             meta.arrays.length &&
             meta.arrays.some((array) => !!array.value.arrays.length)
         )
             throw notSupportedError({ method })("two dimenstional array type");
+        // CHILD OF ARRAY TYPE MUST BE REQUIRED
+        else if (
+            meta.arrays.length &&
+            meta.arrays.some(
+                (array) =>
+                    array.value.isRequired() === false ||
+                    array.value.nullable === true,
+            )
+        )
+            throw notSupportedError({ method })("optional type in array");
+        // UNION IN ARRAY
+        else if (
+            meta.arrays.length &&
+            meta.arrays.some((a) => a.value.size() > 1)
+        )
+            throw notSupportedError({ method })("union type in array");
+        // UNION WITH ARRAY
+        else if (meta.size() > 1 && meta.arrays.length)
+            throw notSupportedError({ method })("union type with array type");
         //----
-        // SPECIAL CASES
+        // OBJECT CASES
         //----
+        // EMPTY PROPERTY
+        else if (
+            meta.objects.length &&
+            meta.objects.some((obj) => obj.properties.length === 0)
+        )
+            throw notSupportedError({ method })("empty object type");
         // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
         else if (
             meta.objects.length &&
@@ -90,7 +122,6 @@ export namespace ProtobufFactory {
             meta.objects.length &&
             meta.objects.some(
                 (obj) =>
-                    obj.properties.length &&
                     obj.properties.some((p) => p.key.isSoleLiteral()) &&
                     obj.properties.some((p) => !p.key.isSoleLiteral()),
             )
@@ -98,36 +129,29 @@ export namespace ProtobufFactory {
             throw notSupportedError({ method })(
                 "object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.",
             );
-        // NATIVE TYPE, BUT NOT Uint8Array
-        else if (meta.natives.length) {
-            const banned = meta.natives
-                .map((n) => [n, BANNED_NATIVE_TYPES.get(n)] as const)
-                .filter(([_n, b]) => b !== undefined)[0];
-            if (banned !== undefined)
-                throw notSupportedError({ method })(
-                    banned[1] === null
-                        ? banned[0]
-                        : `${banned[0]}. Use ${banned[1]} instead.`,
-                );
-        }
-        // MAP TYPE, BUT PROPERTY KEY TYPE IS NOT ATOMIC
+        // STATIC PROPERTY, BUT INVALID KEY NAME
         else if (
-            meta.maps.length &&
-            meta.maps.some((m) => !is_atomic_key(m.key))
+            meta.objects.length &&
+            meta.objects.some((obj) =>
+                obj.properties.some(
+                    (p) =>
+                        p.key.isSoleLiteral() &&
+                        !Escaper.variable(p.key.getSoleLiteral()!),
+                ),
+            )
         )
-            throw notSupportedError({ method })("");
-        //----
-        // UNION TYPES
-        //----
-        // UNION IN ARRAY
+            throw notSupportedError({ method })(
+                `object type with invalid static key name.`,
+            );
+        // DYNAMIC OBJECT, BUT PROPERTY VALUE TYPE IS ARRAY
         else if (
-            meta.arrays.length &&
-            meta.arrays.some((a) => a.value.size() > 1)
+            meta.objects.length &&
+            isDynamicObject(meta.objects[0]!) &&
+            meta.objects[0]!.properties.some((p) => !!p.value.arrays.length)
         )
-            throw notSupportedError({ method })("union type in array");
-        // UNION WITH ARRAY
-        else if (meta.size() > 1 && meta.arrays.length)
-            throw notSupportedError({ method })("union type with array type");
+            throw notSupportedError({ method })(
+                "dynamic object with array value type",
+            );
         // UNION WITH DYNAMIC OBJECT
         else if (
             meta.size() > 1 &&
@@ -143,42 +167,53 @@ export namespace ProtobufFactory {
             meta.objects.some(
                 (obj) =>
                     isDynamicObject(obj) &&
-                    obj.properties.some((p) => isUnion(p.value)),
+                    obj.properties.some((p) => p.value.isBinaryUnion()),
             )
         )
             throw notSupportedError({ method })(
                 "union type in dynamic property",
             );
+        //----
+        // MAP CASES
+        //----
+        // MAP TYPE, BUT PROPERTY KEY TYPE IS NOT STRING
+        else if (
+            meta.maps.length &&
+            meta.maps.some(
+                (m) =>
+                    m.key.isBinaryUnion() ||
+                    (m.key.atomics.find((v) => v === "string") === undefined &&
+                        m.key.constants.find((c) => c.type === "string") ===
+                            undefined),
+            )
+        )
+            throw notSupportedError({ method })("non-string key typed map");
+        // MAP TYPE, BUT PROPERTY KEY TYPE IS OPTIONAL
+        else if (
+            meta.maps.length &&
+            meta.maps.some(
+                (m) => m.key.isRequired() === false || m.key.nullable,
+            )
+        )
+            throw notSupportedError({ method })("optional key typed map");
+        // MAP TYPE, BUT VALUE TYPE IS ARRAY
+        else if (
+            meta.maps.length &&
+            meta.maps.some((m) => !!m.value.arrays.length)
+        )
+            throw notSupportedError({ method })(
+                "map type with array value type",
+            );
         // UNION WITH MAP
         else if (meta.size() > 1 && meta.maps.length)
             throw notSupportedError({ method })("union type with map type");
         // UNION IN MAP
-        else if (meta.maps.length && meta.maps.some((m) => isUnion(m.value)))
+        else if (
+            meta.maps.length &&
+            meta.maps.some((m) => m.value.isBinaryUnion())
+        )
             throw notSupportedError({ method })("union type in map");
     };
-
-    const is_atomic_key = (key: Metadata) => {
-        if (
-            key.required &&
-            key.nullable === false &&
-            key.functional === false &&
-            key.resolved === null &&
-            key.size() ===
-                key.atomics.length +
-                    key.constants
-                        .map((c) => c.values.length)
-                        .reduce((a, b) => a + b, 0) +
-                    key.templates.length
-        ) {
-            const set: Set<string> = new Set();
-            for (const atomic of key.atomics) set.add(atomic);
-            for (const constant of key.constants) set.add(constant.type);
-            if (key.templates.length) set.add("string");
-
-            return set.size === 1;
-        }
-        return false;
-    };
 }
 
 const prefix = (method: string) => `Error on typia.protobuf.${method}():`;
@@ -188,27 +223,8 @@ const notSupportedError = (p: { method: string }) => (title: string) =>
         `${prefix(p.method)}: protocol buffer does not support ${title}.`,
     );
 
-const isDynamicObject = (obj: MetadataObject): boolean => {
-    return (
-        obj.properties.length > 0 &&
-        obj.properties[0]!.key.isSoleLiteral() === false
-    );
-};
-
-const isUnion = (meta: Metadata): boolean => {
-    const count: number =
-        new Set([
-            ...meta.atomics,
-            ...meta.constants.map((c) => c.type),
-            ...(meta.templates.length ? ["string"] : []),
-        ]).size +
-        meta.arrays.length +
-        meta.tuples.length +
-        meta.natives.length +
-        meta.objects.length +
-        meta.maps.length;
-    return count > 1;
-};
+const isDynamicObject = (obj: MetadataObject): boolean =>
+    obj.properties[0]!.key.isSoleLiteral() === false;
 
 const BANNED_NATIVE_TYPES: Map<string, string | null> = new Map([
     ["Date", "string"],

package/src/factories/StatementFactory.ts

@@ -1,6 +1,22 @@
 import ts from "typescript";
 
 export namespace StatementFactory {
+    export const mut = (name: string, initializer?: ts.Expression) =>
+        ts.factory.createVariableStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [
+                    ts.factory.createVariableDeclaration(
+                        name,
+                        undefined,
+                        undefined,
+                        initializer,
+                    ),
+                ],
+                ts.NodeFlags.Let,
+            ),
+        );
+
     export const constant = (name: string, initializer?: ts.Expression) =>
         ts.factory.createVariableStatement(
             undefined,

package/src/factories/internal/metadata/explore_metadata.ts

@@ -18,11 +18,9 @@ export const explore_metadata =
     ): Metadata => {
         // CONSTRUCT METADATA
         const meta: Metadata = Metadata.initialize(parentResolved);
-        const out = (meta: Metadata) => {
-            if (options.validate) options.validate(meta);
-            return meta;
-        };
-        if (type === null) return out(meta);
+        collection.entire_.add(meta);
+
+        if (type === null) return meta;
 
         // ITERATE TYPESCRIPT TYPES
         iterate_metadata(checker)(options)(collection)(
@@ -36,5 +34,5 @@ export const explore_metadata =
             emend_metadata_atomics(meta.resolved.original);
             emend_metadata_atomics(meta.resolved.returns);
         }
-        return out(meta);
+        return meta;
     };

package/src/factories/internal/metadata/iterate_metadata_intersection.ts

@@ -74,6 +74,7 @@ export const iterate_metadata_intersection =
             throw new Error(message(children));
         });
         Object.assign(meta, Metadata.merge(meta, least));
+        collection.entire_.add(least);
         return true;
     };
 

package/src/functional/$strlen.ts

@@ -0,0 +1,7 @@
+export const $strlen = (s: string): number => {
+    let b: number;
+    let i: number;
+    let c: number;
+    for (b = i = 0; (c = s.charCodeAt(i++)); b += c >> 11 ? 3 : c >> 7 ? 2 : 1);
+    return b;
+};

package/src/functional/Namespace.ts

@@ -1,3 +1,5 @@
+import { Writer } from "protobufjs";
+
 import { RandomGenerator } from "../utils/RandomGenerator";
 
 import { IValidation } from "../IValidation";
@@ -19,6 +21,7 @@ import { $number } from "./$number";
 import { $report } from "./$report";
 import { $rest } from "./$rest";
 import { $string } from "./$string";
+import { $strlen } from "./$strlen";
 import { $tail } from "./$tail";
 
 /**
@@ -91,25 +94,37 @@ export namespace Namespace {
             },
     });
 
-    export const stringify = (method: string) => ({
-        ...is(),
-        number: $number,
-        string: $string,
-        tail: $tail,
-        rest: $rest,
-        throws: $throws(method),
-    });
+    export namespace json {
+        export const stringify = (method: string) => ({
+            ...is(),
+            number: $number,
+            string: $string,
+            tail: $tail,
+            rest: $rest,
+            throws: $throws(method),
+        });
+    }
 
-    export const clone = (method: string) => ({
-        ...is(),
-        throws: $throws(method),
-        any: $any,
-    });
+    export namespace protobuf {
+        export const encode = (method: string) => ({
+            Writer: Writer,
+            strl: $strlen,
+            throws: $throws(method),
+        });
+    }
 
-    export const prune = (method: string) => ({
-        ...is(),
-        throws: $throws(method),
-    });
+    export namespace misc {
+        export const clone = (method: string) => ({
+            ...is(),
+            throws: $throws(method),
+            any: $any,
+        });
+
+        export const prune = (method: string) => ({
+            ...is(),
+            throws: $throws(method),
+        });
+    }
 
     export const random = () => ({
         generator: RandomGenerator,

package/src/json.ts

@@ -254,7 +254,7 @@ export function stringify<T>(input: T): string;
 export function stringify(): never {
     halt("stringify");
 }
-Object.assign(stringify, Namespace.stringify("stringify"));
+Object.assign(stringify, Namespace.json.stringify("stringify"));
 
 /**
  * 5x faster `JSON.stringify()` function with type assertion.
@@ -309,7 +309,7 @@ export function assertStringify(): string {
     halt("assertStringify");
 }
 Object.assign(assertStringify, Namespace.assert("assertStringify"));
-Object.assign(assertStringify, Namespace.stringify("assertStringify"));
+Object.assign(assertStringify, Namespace.json.stringify("assertStringify"));
 
 /**
  * 7x faster `JSON.stringify()` function with type checking.
@@ -365,7 +365,7 @@ export function isStringify(): string | null {
 }
 
 Object.assign(isStringify, Namespace.is());
-Object.assign(isStringify, Namespace.stringify("isStringify"));
+Object.assign(isStringify, Namespace.json.stringify("isStringify"));
 
 /**
  * 5x faster `JSON.stringify()` function with detailed type validation.
@@ -422,7 +422,7 @@ export function validateStringify(): IValidation<string> {
     halt("validateStringify");
 }
 Object.assign(validateStringify, Namespace.validate());
-Object.assign(validateStringify, Namespace.stringify("validateStringify"));
+Object.assign(validateStringify, Namespace.json.stringify("validateStringify"));
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS

package/src/misc.ts

@@ -84,7 +84,7 @@ export function clone<T>(input: T): Primitive<T>;
 export function clone(): never {
     halt("clone");
 }
-Object.assign(clone, Namespace.clone("clone"));
+Object.assign(clone, Namespace.misc.clone("clone"));
 
 /**
  * Clone a data with type assertion.
@@ -131,7 +131,7 @@ export function assertClone(): never {
     halt("assertClone");
 }
 Object.assign(assertClone, Namespace.assert("assertClone"));
-Object.assign(assertClone, Namespace.clone("assertClone"));
+Object.assign(assertClone, Namespace.misc.clone("assertClone"));
 
 /**
  * Clone a data with type checking.
@@ -178,7 +178,7 @@ export function isClone(): never {
     halt("isClone");
 }
 Object.assign(isClone, Namespace.is());
-Object.assign(isClone, Namespace.clone("isClone"));
+Object.assign(isClone, Namespace.misc.clone("isClone"));
 
 /**
  * Clone a data with detailed type validation.
@@ -223,7 +223,7 @@ export function validateClone(): never {
     halt("validateClone");
 }
 Object.assign(validateClone, Namespace.validate());
-Object.assign(validateClone, Namespace.clone("validateClone"));
+Object.assign(validateClone, Namespace.misc.clone("validateClone"));
 
 /* -----------------------------------------------------------
     PRUNE
@@ -257,7 +257,7 @@ export function prune<T extends object>(input: T): void;
 export function prune(): never {
     halt("prune");
 }
-Object.assign(prune, Namespace.prune("prune"));
+Object.assign(prune, Namespace.misc.prune("prune"));
 
 /**
  * Prune, erase superfluous properties, with type assertion.
@@ -302,7 +302,7 @@ export function assertPrune(): unknown {
     halt("assertPrune");
 }
 Object.assign(assertPrune, Namespace.assert("assertPrune"));
-Object.assign(assertPrune, Namespace.prune("assertPrune"));
+Object.assign(assertPrune, Namespace.misc.prune("assertPrune"));
 
 /**
  * Prune, erase superfluous properties, with type checking.
@@ -349,7 +349,7 @@ export function isPrune(): never {
     halt("isPrune");
 }
 Object.assign(isPrune, Namespace.is());
-Object.assign(isPrune, Namespace.prune("isPrune"));
+Object.assign(isPrune, Namespace.misc.prune("isPrune"));
 
 /**
  * Prune, erase superfluous properties, with type validation.
@@ -397,7 +397,7 @@ export function validatePrune<T>(input: unknown): IValidation<T>;
 export function validatePrune<T>(): IValidation<T> {
     halt("validatePrune");
 }
-Object.assign(validatePrune, Namespace.prune("validatePrune"));
+Object.assign(validatePrune, Namespace.misc.prune("validatePrune"));
 Object.assign(validatePrune, Namespace.validate());
 
 /* -----------------------------------------------------------

package/src/programmers/CheckerProgrammer.ts

@@ -218,15 +218,6 @@ export namespace CheckerProgrammer {
                         resolve: false,
                         constant: true,
                         absorb: true,
-                        validate: (meta) => {
-                            if (
-                                meta.arrays.length > 1 &&
-                                meta.arrays.some((a) => a.recursive)
-                            )
-                                throw new Error(
-                                    `Repeated union array types are not supported yet.`,
-                                );
-                        },
                     })(collection)(type);
                     return [collection, meta];
                 },

package/src/programmers/FeatureProgrammer.ts

@@ -59,7 +59,7 @@ export namespace FeatureProgrammer {
         /**
          * Object configurator.
          */
-        objector: IConfig.IObjector;
+        objector: IConfig.IObjector<Output>;
 
         /**
          * Generator of functions for object types.
@@ -72,7 +72,9 @@ export namespace FeatureProgrammer {
             output: (type: ts.Type, name?: string) => ts.TypeNode;
         }
 
-        export interface IObjector {
+        export interface IObjector<
+            Output extends ts.ConciseBody = ts.ConciseBody,
+        > {
             /**
              * Type checker when union object type comes.
              */
@@ -88,7 +90,7 @@ export namespace FeatureProgrammer {
              */
             joiner(
                 input: ts.Expression,
-                entries: IExpressionEntry[],
+                entries: IExpressionEntry<Output>[],
                 parent: MetadataObject,
             ): ts.ConciseBody;
 

package/src/programmers/helpers/ProtobufUtil.ts

@@ -0,0 +1,24 @@
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+export namespace ProtobufUtil {
+    export const atomics = (meta: Metadata) => {
+        const set: Set<Atomic.Literal> = new Set();
+
+        for (const atomic of meta.atomics) set.add(atomic);
+        for (const constant of meta.constants) set.add(constant.type);
+        if (meta.templates.length) set.add("string");
+
+        return [...set].sort(
+            (x, y) => ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!,
+        );
+    };
+}
+
+const ATOMIC_ORDER = new Map<Atomic.Literal, number>([
+    ["boolean", 0],
+    ["bigint", 1],
+    ["number", 2],
+    ["string", 3],
+]);

package/src/programmers/helpers/ProtobufWire.ts

@@ -0,0 +1,28 @@
+export const enum ProtobufWire {
+    /**
+     * integers
+     * bool
+     * enum
+     */
+    VARINT = 0,
+
+    /**
+     * fixed64
+     * sfixed64
+     * double
+     */
+    I64 = 1,
+
+    /**
+     * string
+     * bytes
+     * mebedded messages
+     * packed repeated fields
+     */
+    LEN = 2,
+
+    /**
+     * fixed, sfixed32, float
+     */
+    I32 = 5,
+}