typia 6.1.2 → 6.2.0-dev.20240621

package/src/programmers/internal/check_template.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataTemplate } from "../../schemas/metadata/MetadataTemplate";
 
 import { ICheckEntry } from "../helpers/ICheckEntry";
 import { template_to_pattern } from "./template_to_pattern";
@@ -9,7 +9,7 @@ import { template_to_pattern } from "./template_to_pattern";
  * @internal
  */
 export const check_template =
-  (templates: Metadata[][]) =>
+  (templates: MetadataTemplate[]) =>
   (input: ts.Expression): ICheckEntry => {
     // TYPEOF STRING & TAGS
     const conditions: ts.Expression[] = [
@@ -23,7 +23,7 @@ export const check_template =
     const internal: ts.Expression[] = templates.map((tpl) =>
       ts.factory.createCallExpression(
         ts.factory.createIdentifier(
-          `RegExp(/${template_to_pattern(true)(tpl)}/).test`,
+          `RegExp(/${template_to_pattern(true)(tpl.row)}/).test`,
         ),
         undefined,
         [input],
@@ -41,21 +41,6 @@ export const check_template =
         ts.factory.createLogicalAnd(x, y),
       ),
       conditions: [],
-      expected: templates
-        .map(
-          (tpl) =>
-            "`" +
-            tpl
-              .map((child) =>
-                child.isConstant() && child.size() === 1
-                  ? child.constants[0]!.values[0]!.value
-                  : `$\{${child.getName()}\}`,
-              )
-              .join("")
-              .split("`")
-              .join("\\`") +
-            "`",
-        )
-        .join(" | "),
+      expected: templates.map((tpl) => tpl.getName()).join(" | "),
     };
   };

package/src/programmers/internal/metadata_to_pattern.ts

@@ -25,8 +25,8 @@ export const metadata_to_pattern =
       if (a.type === "number" || a.type === "bigint")
         values.push(PatternUtil.NUMBER);
       else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
-    for (const childTpl of meta.templates)
-      values.push("(" + template_to_pattern(false)(childTpl) + ")");
+    for (const { row } of meta.templates)
+      values.push("(" + template_to_pattern(false)(row) + ")");
 
     const pattern: string =
       values.length === 1 ? values[0]! : "(" + values.join("|") + ")";

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -262,7 +262,8 @@ export namespace ProtobufDecodeProgrammer {
                     ) ||
                     value.templates.some(
                       (tpl) =>
-                        tpl.length === 1 && tpl[0]!.getName() === "string",
+                        tpl.row.length === 1 &&
+                        tpl.row[0]!.getName() === "string",
                     )
                   ? ts.factory.createStringLiteral("")
                   : value.objects.length &&

package/src/schemas/metadata/IMetadata.ts

@@ -2,6 +2,7 @@ import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataConstant } from "./IMetadataConstant";
 import { IMetadataEntry } from "./IMetadataEntry";
 import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataTemplate } from "./IMetadataTemplate";
 import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadata {
@@ -13,7 +14,7 @@ export interface IMetadata {
 
   atomics: IMetadataAtomic[];
   constants: IMetadataConstant[];
-  templates: IMetadata[][];
+  templates: IMetadataTemplate[];
   escaped: IMetadataEscaped | null;
 
   rest: IMetadata | null;

package/src/schemas/metadata/IMetadataTemplate.ts

@@ -0,0 +1,7 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataTemplate {
+  row: IMetadata[];
+  tags: IMetadataTypeTag[][] | undefined;
+}

package/src/schemas/metadata/Metadata.ts

@@ -11,6 +11,7 @@ import { MetadataAtomic } from "./MetadataAtomic";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataObject } from "./MetadataObject";
+import { MetadataTemplate } from "./MetadataTemplate";
 import { MetadataTuple } from "./MetadataTuple";
 
 export class Metadata {
@@ -23,7 +24,7 @@ export class Metadata {
   public escaped: MetadataEscaped | null;
   public atomics: MetadataAtomic[];
   public constants: MetadataConstant[];
-  public templates: Metadata[][];
+  public templates: MetadataTemplate[];
 
   public rest: Metadata | null;
   public aliases: MetadataAlias[];
@@ -116,7 +117,7 @@ export class Metadata {
 
       atomics: this.atomics.map((a) => a.toJSON()),
       constants: this.constants.map((c) => c.toJSON()),
-      templates: this.templates.map((tpl) => tpl.map((meta) => meta.toJSON())),
+      templates: this.templates.map((tpl) => tpl.toJSON()),
       escaped: this.escaped ? this.escaped.toJSON() : null,
 
       rest: this.rest ? this.rest.toJSON() : null,
@@ -150,9 +151,7 @@ export class Metadata {
 
       constants: meta.constants.map(MetadataConstant.from),
       atomics: meta.atomics.map(MetadataAtomic.from),
-      templates: meta.templates.map((tpl) =>
-        tpl.map((meta) => this.from(meta, dict)),
-      ),
+      templates: meta.templates.map((tpl) => MetadataTemplate.from(tpl, dict)),
       escaped: meta.escaped ? MetadataEscaped.from(meta.escaped, dict) : null,
 
       rest: meta.rest ? this.from(meta.rest, dict) : null,
@@ -551,20 +550,7 @@ const getName = (metadata: Metadata): string => {
   }
   for (const constant of metadata.constants)
     for (const value of constant.values) elements.push(value.getName());
-  for (const template of metadata.templates)
-    elements.push(
-      "`" +
-        template
-          .map((child) =>
-            child.isConstant() && child.size() === 1
-              ? child.constants[0]!.values[0]!
-              : `$\{${child.getName()}\}`,
-          )
-          .join("")
-          .split("`")
-          .join("\\`") +
-        "`",
-    );
+  for (const template of metadata.templates) elements.push(template.getName());
 
   // NATIVES
   for (const native of metadata.natives) elements.push(native);

package/src/schemas/metadata/MetadataTemplate.ts

@@ -0,0 +1,80 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataTemplate } from "./IMetadataTemplate";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { Metadata } from "./Metadata";
+
+export class MetadataTemplate {
+  public readonly row: Metadata[];
+  public tags: IMetadataTypeTag[][] | undefined;
+
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataTemplate>) {
+    this.row = props.row.map(Metadata.create);
+    this.tags = props.tags;
+  }
+
+  public static create(
+    props: ClassProperties<MetadataTemplate>,
+  ): MetadataTemplate {
+    return new MetadataTemplate(props);
+  }
+
+  public static from(
+    json: IMetadataTemplate,
+    dict: IMetadataDictionary,
+  ): MetadataTemplate {
+    return new MetadataTemplate({
+      row: json.row.map((m) => Metadata.from(m, dict)),
+      tags: json.tags,
+    });
+  }
+
+  public getName(): string {
+    return (this.name_ ??= getName(this));
+  }
+
+  /**
+   * @internal
+   */
+  public getBaseName(): string {
+    return (
+      "`" +
+      this.row
+        .map((child) =>
+          child.isConstant() && child.size() === 1
+            ? child.constants[0]!.values[0]!.value
+            : `$\{${child.getName()}\}`,
+        )
+        .join("")
+        .split("`")
+        .join("\\`") +
+      "`"
+    );
+  }
+
+  public toJSON(): IMetadataTemplate {
+    return {
+      row: this.row.map((m) => m.toJSON()),
+      tags: this.tags,
+    };
+  }
+}
+
+const getName = (template: MetadataTemplate): string => {
+  const base: string = template.getBaseName();
+  if (!template.tags?.length) return base;
+  else if (template.tags.length === 1) {
+    const str: string = [base, ...template.tags[0]!.map((t) => t.name)].join(
+      " & ",
+    );
+    return `(${str})`;
+  }
+  const rows: string[] = template.tags.map((row) => {
+    const str: string = row.map((t) => t.name).join(" & ");
+    return row.length === 1 ? str : `(${str})`;
+  });
+  return `(${base} & (${rows.join(" | ")}))`;
+};