typia 6.10.0 → 6.10.1-dev.20240919

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,160 +1,160 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { ProtobufFactory } from "../../factories/ProtobufFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { IProject } from "../../transformers/IProject";
-
-import { MapUtil } from "../../utils/MapUtil";
-import { NameEncoder } from "../../utils/NameEncoder";
-
-import { ProtobufUtil } from "../helpers/ProtobufUtil";
-
-export namespace ProtobufMessageProgrammer {
-  export const write = (project: IProject) => (type: ts.Type) => {
-    // PARSE TARGET TYPE
-    const collection: MetadataCollection = new MetadataCollection();
-    ProtobufFactory.metadata("message")(project.checker, project.context)(
-      collection,
-    )(type);
-
-    // STRINGIFY
-    const hierarchies: Map<string, Hierarchy> = new Map();
-    for (const obj of collection.objects())
-      if (is_dynamic_object(obj) === false) emplace(hierarchies)(obj);
-
-    const content: string =
-      `syntax = "proto3";\n\n` +
-      [...hierarchies.values()]
-        .map((hier) => write_hierarchy(hier))
-        .join("\n\n");
-
-    // RETURNS
-    return ts.factory.createStringLiteral(content);
-  };
-
-  const emplace = (dict: Map<string, Hierarchy>) => (obj: MetadataObject) => {
-    const accessors: string[] = obj.name.split(".");
-    accessors.forEach((access, i) => {
-      const hierarchy: Hierarchy = MapUtil.take(dict)(access, () => ({
-        key: access,
-        object: null!,
-        children: new Map(),
-      }));
-      dict = hierarchy.children;
-      if (i === accessors.length - 1) hierarchy.object = obj;
-    });
-  };
-
-  const is_dynamic_object = (obj: MetadataObject): boolean =>
-    obj.properties.length === 1 &&
-    obj.properties[0]!.key.isSoleLiteral() === false;
-
-  const write_hierarchy = (hierarchy: Hierarchy): string => {
-    const elements: string[] = [
-      `message ${NameEncoder.encode(hierarchy.key)} {`,
-    ];
-    if (hierarchy.object !== null) {
-      const text: string = write_object(hierarchy.object);
-      elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
-    }
-    if (hierarchy.children.size)
-      elements.push(
-        [...hierarchy.children.values()]
-          .map((child) => write_hierarchy(child))
-          .map((body) =>
-            body
-              .split("\n")
-              .map((line) => `${TAB}${line}`)
-              .join("\n"),
-          )
-          .join("\n\n"),
-      );
-    elements.push("}");
-    return elements.join("\n");
-  };
-
-  const write_object = (obj: MetadataObject): string => {
-    const ptr: IPointer<number> = { value: 0 };
-    return obj.properties
-      .map((prop) => {
-        const key: string = prop.key.getSoleLiteral()!;
-        const type: string = decode(ptr)(prop.value);
-        return type.indexOf("${name}") !== -1
-          ? type.replace("${name}", key)
-          : `${
-              prop.value.arrays.length || type.startsWith("map<")
-                ? ""
-                : !prop.value.isRequired() || prop.value.nullable
-                  ? "optional "
-                  : "required "
-            }${type} ${key} = ${++ptr.value};`;
-      })
-      .join("\n");
-  };
-
-  /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-  const decode =
-    (ptr: IPointer<number>) =>
-    (meta: Metadata): string => {
-      const elements: Set<string> = new Set();
-      if (meta.natives.length) elements.add("bytes");
-      for (const atomic of ProtobufUtil.getAtomics(meta)) elements.add(atomic);
-      for (const array of meta.arrays)
-        elements.add(`repeated ${decode(ptr)(array.type.value)}`);
-      for (const obj of meta.objects)
-        elements.add(
-          is_dynamic_object(obj)
-            ? decode_map(ptr)(
-                MetadataProperty.create({
-                  ...obj.properties[0]!,
-                  key: (() => {
-                    const key: Metadata = Metadata.initialize();
-                    key.atomics.push(
-                      MetadataAtomic.create({
-                        type: "string",
-                        tags: [],
-                      }),
-                    );
-                    return key;
-                  })(),
-                }),
-              )
-            : NameEncoder.encode(obj.name),
-        );
-      for (const map of meta.maps) elements.add(decode_map(ptr)(map));
-      return elements.size === 1
-        ? [...elements][0]!
-        : [
-            "oneof ${name} {",
-            ...[...elements].map(
-              (str) => `${TAB}${str} v${ptr.value + 1} = ${++ptr.value};`,
-            ),
-            "}",
-          ].join("\n");
-    };
-
-  const decode_map =
-    (ptr: IPointer<number>) =>
-    (prop: Metadata.Entry): string =>
-      `map<${decode(ptr)(prop.key)}, ${decode(ptr)(prop.value)}>`;
-}
-
-interface Hierarchy {
-  key: string;
-  object: MetadataObject | null;
-  children: Map<string, Hierarchy>;
-}
-
-interface IPointer<T> {
-  value: T;
-}
-
-const TAB = " ".repeat(2);
+import ts from "typescript";
+
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { ProtobufFactory } from "../../factories/ProtobufFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { IProject } from "../../transformers/IProject";
+
+import { MapUtil } from "../../utils/MapUtil";
+import { NameEncoder } from "../../utils/NameEncoder";
+
+import { ProtobufUtil } from "../helpers/ProtobufUtil";
+
+export namespace ProtobufMessageProgrammer {
+  export const write = (project: IProject) => (type: ts.Type) => {
+    // PARSE TARGET TYPE
+    const collection: MetadataCollection = new MetadataCollection();
+    ProtobufFactory.metadata("message")(project.checker, project.context)(
+      collection,
+    )(type);
+
+    // STRINGIFY
+    const hierarchies: Map<string, Hierarchy> = new Map();
+    for (const obj of collection.objects())
+      if (is_dynamic_object(obj) === false) emplace(hierarchies)(obj);
+
+    const content: string =
+      `syntax = "proto3";\n\n` +
+      [...hierarchies.values()]
+        .map((hier) => write_hierarchy(hier))
+        .join("\n\n");
+
+    // RETURNS
+    return ts.factory.createStringLiteral(content);
+  };
+
+  const emplace = (dict: Map<string, Hierarchy>) => (obj: MetadataObject) => {
+    const accessors: string[] = obj.name.split(".");
+    accessors.forEach((access, i) => {
+      const hierarchy: Hierarchy = MapUtil.take(dict)(access, () => ({
+        key: access,
+        object: null!,
+        children: new Map(),
+      }));
+      dict = hierarchy.children;
+      if (i === accessors.length - 1) hierarchy.object = obj;
+    });
+  };
+
+  const is_dynamic_object = (obj: MetadataObject): boolean =>
+    obj.properties.length === 1 &&
+    obj.properties[0]!.key.isSoleLiteral() === false;
+
+  const write_hierarchy = (hierarchy: Hierarchy): string => {
+    const elements: string[] = [
+      `message ${NameEncoder.encode(hierarchy.key)} {`,
+    ];
+    if (hierarchy.object !== null) {
+      const text: string = write_object(hierarchy.object);
+      elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
+    }
+    if (hierarchy.children.size)
+      elements.push(
+        [...hierarchy.children.values()]
+          .map((child) => write_hierarchy(child))
+          .map((body) =>
+            body
+              .split("\n")
+              .map((line) => `${TAB}${line}`)
+              .join("\n"),
+          )
+          .join("\n\n"),
+      );
+    elements.push("}");
+    return elements.join("\n");
+  };
+
+  const write_object = (obj: MetadataObject): string => {
+    const ptr: IPointer<number> = { value: 0 };
+    return obj.properties
+      .map((prop) => {
+        const key: string = prop.key.getSoleLiteral()!;
+        const type: string = decode(ptr)(prop.value);
+        return type.indexOf("${name}") !== -1
+          ? type.replace("${name}", key)
+          : `${
+              prop.value.arrays.length || type.startsWith("map<")
+                ? ""
+                : !prop.value.isRequired() || prop.value.nullable
+                  ? "optional "
+                  : "required "
+            }${type} ${key} = ${++ptr.value};`;
+      })
+      .join("\n");
+  };
+
+  /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+  const decode =
+    (ptr: IPointer<number>) =>
+    (meta: Metadata): string => {
+      const elements: Set<string> = new Set();
+      if (meta.natives.length) elements.add("bytes");
+      for (const atomic of ProtobufUtil.getAtomics(meta)) elements.add(atomic);
+      for (const array of meta.arrays)
+        elements.add(`repeated ${decode(ptr)(array.type.value)}`);
+      for (const obj of meta.objects)
+        elements.add(
+          is_dynamic_object(obj)
+            ? decode_map(ptr)(
+                MetadataProperty.create({
+                  ...obj.properties[0]!,
+                  key: (() => {
+                    const key: Metadata = Metadata.initialize();
+                    key.atomics.push(
+                      MetadataAtomic.create({
+                        type: "string",
+                        tags: [],
+                      }),
+                    );
+                    return key;
+                  })(),
+                }),
+              )
+            : NameEncoder.encode(obj.name),
+        );
+      for (const map of meta.maps) elements.add(decode_map(ptr)(map));
+      return elements.size === 1
+        ? [...elements][0]!
+        : [
+            "oneof ${name} {",
+            ...[...elements].map(
+              (str) => `${TAB}${str} v${ptr.value + 1} = ${++ptr.value};`,
+            ),
+            "}",
+          ].join("\n");
+    };
+
+  const decode_map =
+    (ptr: IPointer<number>) =>
+    (prop: Metadata.Entry): string =>
+      `map<${decode(ptr)(prop.key)}, ${decode(ptr)(prop.value)}>`;
+}
+
+interface Hierarchy {
+  key: string;
+  object: MetadataObject | null;
+  children: Map<string, Hierarchy>;
+}
+
+interface IPointer<T> {
+  value: T;
+}
+
+const TAB = " ".repeat(2);

package/src/reflect.ts

@@ -1,63 +1,63 @@
-import { IMetadataApplication } from "./schemas/metadata/IMetadataApplication";
-
-/**
- * > You must configure the generic argument `Types`.
- *
- * Metadata Application.
- *
- * Creates a Metadata application which contains the metadata and components.
- *
- * Note that, all of the collection types like Array, Tuple and Objects are
- * stored in the {@link IMetadataApplication.components} property. Also, alias
- * types are stored in the {@link IMetadataApplication.aliases} property, too.
- *
- * @template Types Tuple of target types
- * @returns Metadata application
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-function metadata(): never;
-
-/**
- * Metadata Application.
- *
- * Creates a Metadata application which contains the metadata and components.
- *
- * Note that, all of the collection types like Array, Tuple and Objects are
- * stored in the {@link IMetadataApplication.components} property. Also, alias
- * types are stored in the {@link IMetadataApplication.aliases} property, too.
- *
- * @template Types Tuple of target types
- * @returns Metadata application
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-function metadata<Types extends unknown[]>(): IMetadataApplication;
-
-/**
- * @internal
- */
-function metadata(): never {
-  halt("metadata");
-}
-
-const metadataPure = /** @__PURE__ */ Object.assign<typeof metadata, {}>(
-  metadata,
-  { from: (input: unknown) => input },
-);
-export { metadataPure as metadata };
-
-export function name<T, Regular extends boolean = false>(): string;
-export function name(): never;
-export function name(): never {
-  halt("name");
-}
-
-/**
- * @internal
- */
-function halt(name: string): never {
-  throw new Error(
-    `Error on typia.reflect.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
-  );
-}
+import { IMetadataApplication } from "./schemas/metadata/IMetadataApplication";
+
+/**
+ * > You must configure the generic argument `Types`.
+ *
+ * Metadata Application.
+ *
+ * Creates a Metadata application which contains the metadata and components.
+ *
+ * Note that, all of the collection types like Array, Tuple and Objects are
+ * stored in the {@link IMetadataApplication.components} property. Also, alias
+ * types are stored in the {@link IMetadataApplication.aliases} property, too.
+ *
+ * @template Types Tuple of target types
+ * @returns Metadata application
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function metadata(): never;
+
+/**
+ * Metadata Application.
+ *
+ * Creates a Metadata application which contains the metadata and components.
+ *
+ * Note that, all of the collection types like Array, Tuple and Objects are
+ * stored in the {@link IMetadataApplication.components} property. Also, alias
+ * types are stored in the {@link IMetadataApplication.aliases} property, too.
+ *
+ * @template Types Tuple of target types
+ * @returns Metadata application
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function metadata<Types extends unknown[]>(): IMetadataApplication;
+
+/**
+ * @internal
+ */
+function metadata(): never {
+  halt("metadata");
+}
+
+const metadataPure = /** @__PURE__ */ Object.assign<typeof metadata, {}>(
+  metadata,
+  { from: (input: unknown) => input },
+);
+export { metadataPure as metadata };
+
+export function name<T, Regular extends boolean = false>(): string;
+export function name(): never;
+export function name(): never {
+  halt("name");
+}
+
+/**
+ * @internal
+ */
+function halt(name: string): never {
+  throw new Error(
+    `Error on typia.reflect.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
+  );
+}

package/src/schemas/metadata/IJsDocTagInfo.ts

@@ -1,10 +1,10 @@
-export interface IJsDocTagInfo {
-  name: string;
-  text?: IJsDocTagInfo.IText[];
-}
-export namespace IJsDocTagInfo {
-  export interface IText {
-    text: string;
-    kind: string;
-  }
-}
+export interface IJsDocTagInfo {
+  name: string;
+  text?: IJsDocTagInfo.IText[];
+}
+export namespace IJsDocTagInfo {
+  export interface IText {
+    text: string;
+    kind: string;
+  }
+}

package/src/schemas/metadata/IMetadataAlias.ts

@@ -1,12 +1,12 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataAlias {
-  name: string;
-  value: IMetadata;
-  nullables: boolean[];
-
-  description: string | null;
-  jsDocTags: IJsDocTagInfo[];
-  recursive: boolean;
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataAlias {
+  name: string;
+  value: IMetadata;
+  nullables: boolean[];
+
+  description: string | null;
+  jsDocTags: IJsDocTagInfo[];
+  recursive: boolean;
+}

package/src/schemas/metadata/IMetadataApplication.ts

@@ -1,7 +1,7 @@
-import { IMetadata } from "./IMetadata";
-import { IMetadataComponents } from "./IMetadataComponents";
-
-export interface IMetadataApplication {
-  metadatas: IMetadata[];
-  components: IMetadataComponents;
-}
+import { IMetadata } from "./IMetadata";
+import { IMetadataComponents } from "./IMetadataComponents";
+
+export interface IMetadataApplication {
+  metadatas: IMetadata[];
+  components: IMetadataComponents;
+}

package/src/schemas/metadata/IMetadataArray.ts

@@ -1,7 +1,7 @@
-import { IMetadataArrayType } from "./IMetadataArrayType";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataArray {
-  type: IMetadataArrayType;
-  tags: IMetadataTypeTag[][];
-}
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataArray {
+  type: IMetadataArrayType;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataArrayType.ts

@@ -1,10 +1,10 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataArrayType {
-  name: string;
-  value: IMetadata;
-
-  nullables: boolean[];
-  recursive: boolean;
-  index: number | null;
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataArrayType {
+  name: string;
+  value: IMetadata;
+
+  nullables: boolean[];
+  recursive: boolean;
+  index: number | null;
+}

package/src/schemas/metadata/IMetadataAtomic.ts

@@ -1,6 +1,6 @@
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataAtomic {
-  type: "boolean" | "bigint" | "number" | "string";
-  tags: IMetadataTypeTag[][];
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataAtomic {
+  type: "boolean" | "bigint" | "number" | "string";
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataComponents.ts

@@ -1,11 +1,11 @@
-import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataArrayType } from "./IMetadataArrayType";
-import { IMetadataObject } from "./IMetadataObject";
-import { IMetadataTupleType } from "./IMetadataTupleType";
-
-export interface IMetadataComponents {
-  objects: IMetadataObject[];
-  aliases: IMetadataAlias[];
-  arrays: IMetadataArrayType[];
-  tuples: IMetadataTupleType[];
-}
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataTupleType } from "./IMetadataTupleType";
+
+export interface IMetadataComponents {
+  objects: IMetadataObject[];
+  aliases: IMetadataAlias[];
+  arrays: IMetadataArrayType[];
+  tuples: IMetadataTupleType[];
+}

package/src/schemas/metadata/IMetadataConstant.ts

@@ -1,18 +1,18 @@
-import { Atomic } from "../../typings/Atomic";
-
-import { IMetadataConstantValue } from "./IMetadataConstantValue";
-
-export type IMetadataConstant =
-  | IMetadataConstant.IBase<"boolean", boolean>
-  | IMetadataConstant.IBase<"number", number>
-  | IMetadataConstant.IBase<"string", string>
-  | IMetadataConstant.IBase<"bigint", string>;
-export namespace IMetadataConstant {
-  export interface IBase<
-    Type extends Atomic.Literal,
-    Value extends Atomic.Type,
-  > {
-    type: Type;
-    values: IMetadataConstantValue<Value>[];
-  }
-}
+import { Atomic } from "../../typings/Atomic";
+
+import { IMetadataConstantValue } from "./IMetadataConstantValue";
+
+export type IMetadataConstant =
+  | IMetadataConstant.IBase<"boolean", boolean>
+  | IMetadataConstant.IBase<"number", number>
+  | IMetadataConstant.IBase<"string", string>
+  | IMetadataConstant.IBase<"bigint", string>;
+export namespace IMetadataConstant {
+  export interface IBase<
+    Type extends Atomic.Literal,
+    Value extends Atomic.Type,
+  > {
+    type: Type;
+    values: IMetadataConstantValue<Value>[];
+  }
+}

package/src/schemas/metadata/IMetadataDictionary.ts

@@ -1,11 +1,11 @@
-import { MetadataAlias } from "./MetadataAlias";
-import { MetadataArrayType } from "./MetadataArrayType";
-import { MetadataObject } from "./MetadataObject";
-import { MetadataTupleType } from "./MetadataTupleType";
-
-export interface IMetadataDictionary {
-  objects: Map<string, MetadataObject>;
-  aliases: Map<string, MetadataAlias>;
-  arrays: Map<string, MetadataArrayType>;
-  tuples: Map<string, MetadataTupleType>;
-}
+import { MetadataAlias } from "./MetadataAlias";
+import { MetadataArrayType } from "./MetadataArrayType";
+import { MetadataObject } from "./MetadataObject";
+import { MetadataTupleType } from "./MetadataTupleType";
+
+export interface IMetadataDictionary {
+  objects: Map<string, MetadataObject>;
+  aliases: Map<string, MetadataAlias>;
+  arrays: Map<string, MetadataArrayType>;
+  tuples: Map<string, MetadataTupleType>;
+}

package/src/schemas/metadata/IMetadataEntry.ts

@@ -1,6 +1,6 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataEntry {
-  key: IMetadata;
-  value: IMetadata;
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataEntry {
+  key: IMetadata;
+  value: IMetadata;
+}