typia 6.6.2 → 6.7.0-dev.20240802

package/src/factories/TemplateFactory.ts

@@ -1,56 +1,56 @@
-import ts from "typescript";
-
-export namespace TemplateFactory {
-  export const generate = (expressions: ts.Expression[]): ts.Expression => {
-    if (expressions.every((exp) => ts.isStringLiteral(exp)))
-      return ts.factory.createStringLiteral(
-        (expressions as ts.StringLiteral[]).map((str) => str.text).join(""),
-      );
-
-    const it: IIterator = {
-      value: "",
-      index: 0,
-    };
-    gather(expressions)(it);
-
-    const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
-    const spans: ts.TemplateSpan[] = [];
-
-    while (true) {
-      const elem: ts.Expression = expressions[it.index++]!;
-      gather(expressions)(it);
-
-      const broken: boolean = it.index === expressions.length;
-      spans.push(
-        ts.factory.createTemplateSpan(
-          elem,
-          broken
-            ? ts.factory.createTemplateTail(it.value)
-            : ts.factory.createTemplateMiddle(it.value),
-        ),
-      );
-      if (broken === true) break;
-    }
-    return ts.factory.createTemplateExpression(head, spans);
-  };
-
-  const gather =
-    (expressions: ts.Expression[]) =>
-    (it: IIterator): void => {
-      const found: number = expressions.findIndex(
-        (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
-      );
-
-      const last: number = found !== -1 ? found : expressions.length;
-      it.value = expressions
-        .slice(it.index, last)
-        .map((elem) => (elem as ts.StringLiteral).text)
-        .reduce((x, y) => x + y, "");
-      it.index = last;
-    };
-
-  interface IIterator {
-    value: string;
-    index: number;
-  }
-}
+import ts from "typescript";
+
+export namespace TemplateFactory {
+  export const generate = (expressions: ts.Expression[]): ts.Expression => {
+    if (expressions.every((exp) => ts.isStringLiteral(exp)))
+      return ts.factory.createStringLiteral(
+        (expressions as ts.StringLiteral[]).map((str) => str.text).join(""),
+      );
+
+    const it: IIterator = {
+      value: "",
+      index: 0,
+    };
+    gather(expressions)(it);
+
+    const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
+    const spans: ts.TemplateSpan[] = [];
+
+    while (true) {
+      const elem: ts.Expression = expressions[it.index++]!;
+      gather(expressions)(it);
+
+      const broken: boolean = it.index === expressions.length;
+      spans.push(
+        ts.factory.createTemplateSpan(
+          elem,
+          broken
+            ? ts.factory.createTemplateTail(it.value)
+            : ts.factory.createTemplateMiddle(it.value),
+        ),
+      );
+      if (broken === true) break;
+    }
+    return ts.factory.createTemplateExpression(head, spans);
+  };
+
+  const gather =
+    (expressions: ts.Expression[]) =>
+    (it: IIterator): void => {
+      const found: number = expressions.findIndex(
+        (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
+      );
+
+      const last: number = found !== -1 ? found : expressions.length;
+      it.value = expressions
+        .slice(it.index, last)
+        .map((elem) => (elem as ts.StringLiteral).text)
+        .reduce((x, y) => x + y, "");
+      it.index = last;
+    };
+
+  interface IIterator {
+    value: string;
+    index: number;
+  }
+}

package/src/factories/TypeFactory.ts

@@ -1,118 +1,118 @@
-import ts from "typescript";
-
-export namespace TypeFactory {
-  export const isFunction = (type: ts.Type): boolean =>
-    getFunction(type) !== null;
-
-  const getFunction = (type: ts.Type) => {
-    const node = type.symbol?.declarations?.[0];
-    if (node === undefined) return null;
-
-    return ts.isFunctionLike(node)
-      ? node
-      : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
-        ? ts.isFunctionLike(node.initializer)
-          ? node.initializer
-          : null
-        : null;
-  };
-
-  export const getReturnType =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type) =>
-    (name: string): ts.Type | null => {
-      // FIND TO-JSON METHOD
-      const symbol: ts.Symbol | undefined = type.getProperty(name);
-      if (!symbol) return null;
-      else if (!symbol.valueDeclaration) return null;
-
-      // GET FUNCTION DECLARATION
-      const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
-        symbol,
-        symbol.valueDeclaration,
-      );
-
-      // RETURNS THE RETURN-TYPE
-      const signature: ts.Signature | undefined = checker.getSignaturesOfType(
-        functor,
-        ts.SignatureKind.Call,
-      )[0];
-      return signature ? signature.getReturnType() : null;
-    };
-
-  export const getFullName =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type, symbol?: ts.Symbol): string => {
-      // PRIMITIVE
-      symbol ??= type.aliasSymbol ?? type.getSymbol();
-      if (symbol === undefined) return checker.typeToString(type);
-
-      // UNION OR INTERSECT
-      if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-        const joiner: string = type.isIntersection() ? " & " : " | ";
-        return type.types
-          .map((child) => getFullName(checker)(child))
-          .join(joiner);
-      }
-
-      //----
-      // SPECIALIZATION
-      //----
-      const name: string = get_name(symbol);
-
-      // CHECK GENERIC
-      const generic: readonly ts.Type[] = type.aliasSymbol
-        ? type.aliasTypeArguments || []
-        : checker.getTypeArguments(type as ts.TypeReference);
-      return generic.length
-        ? name === "Promise"
-          ? getFullName(checker)(generic[0]!)
-          : `${name}<${generic
-              .map((child) => getFullName(checker)(child))
-              .join(", ")}>`
-        : name;
-    };
-
-  const explore_name =
-    (decl: ts.Node) =>
-    (name: string): string =>
-      ts.isModuleBlock(decl)
-        ? explore_name(decl.parent.parent)(
-            `${decl.parent.name.getFullText().trim()}.${name}`,
-          )
-        : name;
-
-  const get_name = (symbol: ts.Symbol): string => {
-    const parent = symbol.getDeclarations()?.[0]?.parent;
-    return parent
-      ? explore_name(parent)(symbol.escapedName.toString())
-      : "__type";
-  };
-
-  export const keyword = (
-    type:
-      | "void"
-      | "any"
-      | "unknown"
-      | "boolean"
-      | "number"
-      | "bigint"
-      | "string",
-  ) => {
-    return ts.factory.createKeywordTypeNode(
-      type === "void"
-        ? ts.SyntaxKind.VoidKeyword
-        : type === "any"
-          ? ts.SyntaxKind.AnyKeyword
-          : type === "unknown"
-            ? ts.SyntaxKind.UnknownKeyword
-            : type === "boolean"
-              ? ts.SyntaxKind.BooleanKeyword
-              : type === "number"
-                ? ts.SyntaxKind.NumberKeyword
-                : type === "bigint"
-                  ? ts.SyntaxKind.BigIntKeyword
-                  : ts.SyntaxKind.StringKeyword,
-    );
-  };
-}
+import ts from "typescript";
+
+export namespace TypeFactory {
+  export const isFunction = (type: ts.Type): boolean =>
+    getFunction(type) !== null;
+
+  const getFunction = (type: ts.Type) => {
+    const node = type.symbol?.declarations?.[0];
+    if (node === undefined) return null;
+
+    return ts.isFunctionLike(node)
+      ? node
+      : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
+        ? ts.isFunctionLike(node.initializer)
+          ? node.initializer
+          : null
+        : null;
+  };
+
+  export const getReturnType =
+    (checker: ts.TypeChecker) =>
+    (type: ts.Type) =>
+    (name: string): ts.Type | null => {
+      // FIND TO-JSON METHOD
+      const symbol: ts.Symbol | undefined = type.getProperty(name);
+      if (!symbol) return null;
+      else if (!symbol.valueDeclaration) return null;
+
+      // GET FUNCTION DECLARATION
+      const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
+        symbol,
+        symbol.valueDeclaration,
+      );
+
+      // RETURNS THE RETURN-TYPE
+      const signature: ts.Signature | undefined = checker.getSignaturesOfType(
+        functor,
+        ts.SignatureKind.Call,
+      )[0];
+      return signature ? signature.getReturnType() : null;
+    };
+
+  export const getFullName =
+    (checker: ts.TypeChecker) =>
+    (type: ts.Type, symbol?: ts.Symbol): string => {
+      // PRIMITIVE
+      symbol ??= type.aliasSymbol ?? type.getSymbol();
+      if (symbol === undefined) return checker.typeToString(type);
+
+      // UNION OR INTERSECT
+      if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
+        const joiner: string = type.isIntersection() ? " & " : " | ";
+        return type.types
+          .map((child) => getFullName(checker)(child))
+          .join(joiner);
+      }
+
+      //----
+      // SPECIALIZATION
+      //----
+      const name: string = get_name(symbol);
+
+      // CHECK GENERIC
+      const generic: readonly ts.Type[] = type.aliasSymbol
+        ? type.aliasTypeArguments || []
+        : checker.getTypeArguments(type as ts.TypeReference);
+      return generic.length
+        ? name === "Promise"
+          ? getFullName(checker)(generic[0]!)
+          : `${name}<${generic
+              .map((child) => getFullName(checker)(child))
+              .join(", ")}>`
+        : name;
+    };
+
+  const explore_name =
+    (decl: ts.Node) =>
+    (name: string): string =>
+      ts.isModuleBlock(decl)
+        ? explore_name(decl.parent.parent)(
+            `${decl.parent.name.getFullText().trim()}.${name}`,
+          )
+        : name;
+
+  const get_name = (symbol: ts.Symbol): string => {
+    const parent = symbol.getDeclarations()?.[0]?.parent;
+    return parent
+      ? explore_name(parent)(symbol.escapedName.toString())
+      : "__type";
+  };
+
+  export const keyword = (
+    type:
+      | "void"
+      | "any"
+      | "unknown"
+      | "boolean"
+      | "number"
+      | "bigint"
+      | "string",
+  ) => {
+    return ts.factory.createKeywordTypeNode(
+      type === "void"
+        ? ts.SyntaxKind.VoidKeyword
+        : type === "any"
+          ? ts.SyntaxKind.AnyKeyword
+          : type === "unknown"
+            ? ts.SyntaxKind.UnknownKeyword
+            : type === "boolean"
+              ? ts.SyntaxKind.BooleanKeyword
+              : type === "number"
+                ? ts.SyntaxKind.NumberKeyword
+                : type === "bigint"
+                  ? ts.SyntaxKind.BigIntKeyword
+                  : ts.SyntaxKind.StringKeyword,
+    );
+  };
+}

package/src/factories/ValueFactory.ts

@@ -1,12 +1,12 @@
-import ts from "typescript";
-
-export namespace ValueFactory {
-  export const NULL = () => ts.factory.createNull();
-  export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
-  export const BOOLEAN = (value: boolean) =>
-    value ? ts.factory.createTrue() : ts.factory.createFalse();
-  export const INPUT = (str: string = "input") =>
-    ts.factory.createIdentifier(str);
-  export const TYPEOF = (input: ts.Expression) =>
-    ts.factory.createTypeOfExpression(input);
-}
+import ts from "typescript";
+
+export namespace ValueFactory {
+  export const NULL = () => ts.factory.createNull();
+  export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
+  export const BOOLEAN = (value: boolean) =>
+    value ? ts.factory.createTrue() : ts.factory.createFalse();
+  export const INPUT = (str: string = "input") =>
+    ts.factory.createIdentifier(str);
+  export const TYPEOF = (input: ts.Expression) =>
+    ts.factory.createTypeOfExpression(input);
+}

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

@@ -1,21 +1,21 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
-
-export namespace MetadataHelper {
-  export const literal_to_metadata = (key: string): Metadata => {
-    const metadata: Metadata = Metadata.initialize();
-    metadata.constants.push(
-      MetadataConstant.create({
-        type: "string",
-        values: [
-          MetadataConstantValue.create({
-            value: key,
-            tags: undefined,
-          }),
-        ],
-      }),
-    );
-    return metadata;
-  };
-}
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
+
+export namespace MetadataHelper {
+  export const literal_to_metadata = (key: string): Metadata => {
+    const metadata: Metadata = Metadata.initialize();
+    metadata.constants.push(
+      MetadataConstant.create({
+        type: "string",
+        values: [
+          MetadataConstantValue.create({
+            value: key,
+            tags: undefined,
+          }),
+        ],
+      }),
+    );
+    return metadata;
+  };
+}

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

@@ -1,45 +1,45 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-export const emend_metadata_atomics = (meta: Metadata) => {
-  // ATOMICS
-  for (const a of meta.atomics) {
-    if (is_not_pure(a)) continue;
-    const index: number = meta.constants.findIndex((c) => c.type === a.type);
-    if (index !== -1) meta.constants.splice(index, 1);
-  }
-
-  // BOOLEAN
-  {
-    const index: number = meta.constants.findIndex((c) => c.type === "boolean");
-    if (index !== -1 && meta.constants[index]!.values.length === 2) {
-      const temp = meta.constants.splice(index, 1)[0]!;
-      ArrayUtil.take(
-        meta.atomics,
-        (a) => a.type === "boolean",
-        () =>
-          MetadataAtomic.create({
-            type: "boolean" as const,
-            tags: temp.values[0]!.tags ?? [],
-          }),
-      );
-    }
-  }
-
-  // TEMPLATE
-  if (meta.templates.length) {
-    const atomic: MetadataAtomic | undefined = meta.atomics.find(
-      (a) => a.type === "string",
-    );
-    if (atomic !== undefined && false === is_not_pure(atomic))
-      meta.templates.splice(0, meta.templates.length);
-  }
-};
-
-const is_not_pure = (atomic: MetadataAtomic): boolean =>
-  atomic.tags.length !== 0 &&
-  atomic.tags.every(
-    (row) => row.length !== 0 && row.every((c) => !!c.validate?.length),
-  );
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+export const emend_metadata_atomics = (meta: Metadata) => {
+  // ATOMICS
+  for (const a of meta.atomics) {
+    if (is_not_pure(a)) continue;
+    const index: number = meta.constants.findIndex((c) => c.type === a.type);
+    if (index !== -1) meta.constants.splice(index, 1);
+  }
+
+  // BOOLEAN
+  {
+    const index: number = meta.constants.findIndex((c) => c.type === "boolean");
+    if (index !== -1 && meta.constants[index]!.values.length === 2) {
+      const temp = meta.constants.splice(index, 1)[0]!;
+      ArrayUtil.take(
+        meta.atomics,
+        (a) => a.type === "boolean",
+        () =>
+          MetadataAtomic.create({
+            type: "boolean" as const,
+            tags: temp.values[0]!.tags ?? [],
+          }),
+      );
+    }
+  }
+
+  // TEMPLATE
+  if (meta.templates.length) {
+    const atomic: MetadataAtomic | undefined = meta.atomics.find(
+      (a) => a.type === "string",
+    );
+    if (atomic !== undefined && false === is_not_pure(atomic))
+      meta.templates.splice(0, meta.templates.length);
+  }
+};
+
+const is_not_pure = (atomic: MetadataAtomic): boolean =>
+  atomic.tags.length !== 0 &&
+  atomic.tags.every(
+    (row) => row.length !== 0 && row.every((c) => !!c.validate?.length),
+  );

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

@@ -1,41 +1,41 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_alias =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    type: ts.Type,
-    nullable: boolean,
-    explore: MetadataFactory.IExplore,
-  ): MetadataAlias => {
-    // CHECK EXISTENCE
-    const [alias, newbie, closure] = collection.emplaceAlias(
-      checker,
-      type,
-      type.aliasSymbol!,
-    );
-    ArrayUtil.add(alias.nullables, nullable);
-    if (newbie === false) return alias;
-
-    // CONSTRUCT VALUE TYPE
-    const value: Metadata = explore_metadata(checker)(options)(collection)(
-      errors,
-    )(type, {
-      ...explore,
-      escaped: false,
-      aliased: true,
-    });
-    closure(value);
-    return alias;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_alias =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    type: ts.Type,
+    nullable: boolean,
+    explore: MetadataFactory.IExplore,
+  ): MetadataAlias => {
+    // CHECK EXISTENCE
+    const [alias, newbie, closure] = collection.emplaceAlias(
+      checker,
+      type,
+      type.aliasSymbol!,
+    );
+    ArrayUtil.add(alias.nullables, nullable);
+    if (newbie === false) return alias;
+
+    // CONSTRUCT VALUE TYPE
+    const value: Metadata = explore_metadata(checker)(options)(collection)(
+      errors,
+    )(type, {
+      ...explore,
+      escaped: false,
+      aliased: true,
+    });
+    closure(value);
+    return alias;
+  };