typia 7.2.1 → 7.3.0-dev.20241213

package/src/factories/StatementFactory.ts

@@ -1,90 +1,90 @@
-import ts from "typescript";
-
-import { TypeFactory } from "./TypeFactory";
-
-export namespace StatementFactory {
-  export const mut = (props: {
-    name: string;
-    type?: ts.TypeNode | undefined;
-    initializer?: ts.Expression | undefined;
-  }) =>
-    ts.factory.createVariableStatement(
-      undefined,
-      ts.factory.createVariableDeclarationList(
-        [
-          ts.factory.createVariableDeclaration(
-            props.name,
-            undefined,
-            props.type !== undefined
-              ? props.type
-              : props.initializer === undefined
-                ? TypeFactory.keyword("any")
-                : undefined,
-            props.initializer,
-          ),
-        ],
-        ts.NodeFlags.Let,
-      ),
-    );
-
-  export const constant = (props: {
-    name: string;
-    type?: ts.TypeNode | undefined;
-    value?: ts.Expression | undefined;
-  }) =>
-    ts.factory.createVariableStatement(
-      undefined,
-      ts.factory.createVariableDeclarationList(
-        [
-          ts.factory.createVariableDeclaration(
-            props.name,
-            undefined,
-            props.type !== undefined
-              ? props.type
-              : props.value === undefined
-                ? TypeFactory.keyword("any")
-                : undefined,
-            props.value,
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    );
-
-  export const entry = (props: { key: string; value: string }) =>
-    ts.factory.createVariableDeclarationList(
-      [
-        ts.factory.createVariableDeclaration(
-          ts.factory.createArrayBindingPattern([
-            ts.factory.createBindingElement(
-              undefined,
-              undefined,
-              ts.factory.createIdentifier(props.key),
-              undefined,
-            ),
-            ts.factory.createBindingElement(
-              undefined,
-              undefined,
-              ts.factory.createIdentifier(props.value),
-              undefined,
-            ),
-          ]),
-          undefined,
-          undefined,
-          undefined,
-        ),
-      ],
-      ts.NodeFlags.Const,
-    );
-
-  export const transpile = (script: string) =>
-    ts.factory.createExpressionStatement(
-      ts.factory.createIdentifier(ts.transpile(script)),
-    );
-
-  export const block = (expression: ts.Expression) =>
-    ts.factory.createBlock(
-      [ts.factory.createExpressionStatement(expression)],
-      true,
-    );
-}
+import ts from "typescript";
+
+import { TypeFactory } from "./TypeFactory";
+
+export namespace StatementFactory {
+  export const mut = (props: {
+    name: string;
+    type?: ts.TypeNode | undefined;
+    initializer?: ts.Expression | undefined;
+  }) =>
+    ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type !== undefined
+              ? props.type
+              : props.initializer === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.initializer,
+          ),
+        ],
+        ts.NodeFlags.Let,
+      ),
+    );
+
+  export const constant = (props: {
+    name: string;
+    type?: ts.TypeNode | undefined;
+    value?: ts.Expression | undefined;
+  }) =>
+    ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type !== undefined
+              ? props.type
+              : props.value === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.value,
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+
+  export const entry = (props: { key: string; value: string }) =>
+    ts.factory.createVariableDeclarationList(
+      [
+        ts.factory.createVariableDeclaration(
+          ts.factory.createArrayBindingPattern([
+            ts.factory.createBindingElement(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier(props.key),
+              undefined,
+            ),
+            ts.factory.createBindingElement(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier(props.value),
+              undefined,
+            ),
+          ]),
+          undefined,
+          undefined,
+          undefined,
+        ),
+      ],
+      ts.NodeFlags.Const,
+    );
+
+  export const transpile = (script: string) =>
+    ts.factory.createExpressionStatement(
+      ts.factory.createIdentifier(ts.transpile(script)),
+    );
+
+  export const block = (expression: ts.Expression) =>
+    ts.factory.createBlock(
+      [ts.factory.createExpressionStatement(expression)],
+      true,
+    );
+}

package/src/factories/TemplateFactory.ts

@@ -1,64 +1,64 @@
-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 iterator: IIterator = {
-      value: "",
-      index: 0,
-    };
-    gather({
-      expressions,
-      iterator,
-    });
-
-    const head: ts.TemplateHead = ts.factory.createTemplateHead(iterator.value);
-    const spans: ts.TemplateSpan[] = [];
-
-    while (true) {
-      const elem: ts.Expression = expressions[iterator.index++]!;
-      gather({
-        expressions,
-        iterator,
-      });
-
-      const broken: boolean = iterator.index === expressions.length;
-      spans.push(
-        ts.factory.createTemplateSpan(
-          elem,
-          broken
-            ? ts.factory.createTemplateTail(iterator.value)
-            : ts.factory.createTemplateMiddle(iterator.value),
-        ),
-      );
-      if (broken === true) break;
-    }
-    return ts.factory.createTemplateExpression(head, spans);
-  };
-
-  const gather = (props: {
-    expressions: ts.Expression[];
-    iterator: IIterator;
-  }): void => {
-    const found: number = props.expressions.findIndex(
-      (elem, index) =>
-        index >= props.iterator.index && !ts.isStringLiteral(elem),
-    );
-
-    const last: number = found !== -1 ? found : props.expressions.length;
-    props.iterator.value = props.expressions
-      .slice(props.iterator.index, last)
-      .map((elem) => (elem as ts.StringLiteral).text)
-      .reduce((x, y) => x + y, "");
-    props.iterator.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 iterator: IIterator = {
+      value: "",
+      index: 0,
+    };
+    gather({
+      expressions,
+      iterator,
+    });
+
+    const head: ts.TemplateHead = ts.factory.createTemplateHead(iterator.value);
+    const spans: ts.TemplateSpan[] = [];
+
+    while (true) {
+      const elem: ts.Expression = expressions[iterator.index++]!;
+      gather({
+        expressions,
+        iterator,
+      });
+
+      const broken: boolean = iterator.index === expressions.length;
+      spans.push(
+        ts.factory.createTemplateSpan(
+          elem,
+          broken
+            ? ts.factory.createTemplateTail(iterator.value)
+            : ts.factory.createTemplateMiddle(iterator.value),
+        ),
+      );
+      if (broken === true) break;
+    }
+    return ts.factory.createTemplateExpression(head, spans);
+  };
+
+  const gather = (props: {
+    expressions: ts.Expression[];
+    iterator: IIterator;
+  }): void => {
+    const found: number = props.expressions.findIndex(
+      (elem, index) =>
+        index >= props.iterator.index && !ts.isStringLiteral(elem),
+    );
+
+    const last: number = found !== -1 ? found : props.expressions.length;
+    props.iterator.value = props.expressions
+      .slice(props.iterator.index, last)
+      .map((elem) => (elem as ts.StringLiteral).text)
+      .reduce((x, y) => x + y, "");
+    props.iterator.index = last;
+  };
+
+  interface IIterator {
+    value: string;
+    index: number;
+  }
+}

package/src/factories/TypeFactory.ts

@@ -1,140 +1,140 @@
-import ts from "typescript";
-
-export namespace TypeFactory {
-  export const isFunction = (type: ts.Type): boolean =>
-    getFunction(type) !== null;
-
-  export 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 getReturnTypeOfClassMethod = (props: {
-    checker: ts.TypeChecker;
-    class: ts.Type;
-    function: string;
-  }): ts.Type | null => {
-    // FIND TO-JSON METHOD
-    const symbol: ts.Symbol | undefined = props.class.getProperty(
-      props.function,
-    );
-    if (!symbol) return null;
-    else if (!symbol.valueDeclaration) return null;
-
-    // GET FUNCTION DECLARATION
-    const functor: ts.Type = props.checker.getTypeOfSymbolAtLocation(
-      symbol,
-      symbol.valueDeclaration,
-    );
-
-    // RETURNS THE RETURN-TYPE
-    const signature: ts.Signature | undefined =
-      props.checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
-    return signature ? signature.getReturnType() : null;
-  };
-
-  export const getFullName = (props: {
-    checker: ts.TypeChecker;
-    type: ts.Type;
-    symbol?: ts.Symbol;
-  }): string => {
-    // PRIMITIVE
-    const symbol =
-      props.symbol ?? props.type.aliasSymbol ?? props.type.getSymbol();
-    if (symbol === undefined) return props.checker.typeToString(props.type);
-
-    // UNION OR INTERSECT
-    if (
-      props.type.aliasSymbol === undefined &&
-      props.type.isUnionOrIntersection()
-    ) {
-      const joiner: string = props.type.isIntersection() ? " & " : " | ";
-      return props.type.types
-        .map((child) =>
-          getFullName({
-            checker: props.checker,
-            type: child,
-          }),
-        )
-        .join(joiner);
-    }
-
-    //----
-    // SPECIALIZATION
-    //----
-    const name: string = get_name(symbol);
-
-    // CHECK GENERIC
-    const generic: readonly ts.Type[] = props.type.aliasSymbol
-      ? (props.type.aliasTypeArguments ?? [])
-      : props.checker.getTypeArguments(props.type as ts.TypeReference);
-    return generic.length
-      ? name === "Promise"
-        ? getFullName({
-            checker: props.checker,
-            type: generic[0]!,
-          })
-        : `${name}<${generic
-            .map((child) =>
-              getFullName({
-                checker: props.checker,
-                type: child,
-              }),
-            )
-            .join(", ")}>`
-      : name;
-  };
-
-  const explore_name = (props: { node: ts.Node; name: string }): string =>
-    ts.isModuleBlock(props.node)
-      ? explore_name({
-          node: props.node.parent.parent,
-          name: `${props.node.parent.name.getFullText().trim()}.${props.name}`,
-        })
-      : props.name;
-
-  const get_name = (symbol: ts.Symbol): string => {
-    const parent = symbol.getDeclarations()?.[0]?.parent;
-    return parent
-      ? explore_name({
-          node: parent,
-          name: 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;
+
+  export 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 getReturnTypeOfClassMethod = (props: {
+    checker: ts.TypeChecker;
+    class: ts.Type;
+    function: string;
+  }): ts.Type | null => {
+    // FIND TO-JSON METHOD
+    const symbol: ts.Symbol | undefined = props.class.getProperty(
+      props.function,
+    );
+    if (!symbol) return null;
+    else if (!symbol.valueDeclaration) return null;
+
+    // GET FUNCTION DECLARATION
+    const functor: ts.Type = props.checker.getTypeOfSymbolAtLocation(
+      symbol,
+      symbol.valueDeclaration,
+    );
+
+    // RETURNS THE RETURN-TYPE
+    const signature: ts.Signature | undefined =
+      props.checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
+    return signature ? signature.getReturnType() : null;
+  };
+
+  export const getFullName = (props: {
+    checker: ts.TypeChecker;
+    type: ts.Type;
+    symbol?: ts.Symbol;
+  }): string => {
+    // PRIMITIVE
+    const symbol =
+      props.symbol ?? props.type.aliasSymbol ?? props.type.getSymbol();
+    if (symbol === undefined) return props.checker.typeToString(props.type);
+
+    // UNION OR INTERSECT
+    if (
+      props.type.aliasSymbol === undefined &&
+      props.type.isUnionOrIntersection()
+    ) {
+      const joiner: string = props.type.isIntersection() ? " & " : " | ";
+      return props.type.types
+        .map((child) =>
+          getFullName({
+            checker: props.checker,
+            type: child,
+          }),
+        )
+        .join(joiner);
+    }
+
+    //----
+    // SPECIALIZATION
+    //----
+    const name: string = get_name(symbol);
+
+    // CHECK GENERIC
+    const generic: readonly ts.Type[] = props.type.aliasSymbol
+      ? (props.type.aliasTypeArguments ?? [])
+      : props.checker.getTypeArguments(props.type as ts.TypeReference);
+    return generic.length
+      ? name === "Promise"
+        ? getFullName({
+            checker: props.checker,
+            type: generic[0]!,
+          })
+        : `${name}<${generic
+            .map((child) =>
+              getFullName({
+                checker: props.checker,
+                type: child,
+              }),
+            )
+            .join(", ")}>`
+      : name;
+  };
+
+  const explore_name = (props: { node: ts.Node; name: string }): string =>
+    ts.isModuleBlock(props.node)
+      ? explore_name({
+          node: props.node.parent.parent,
+          name: `${props.node.parent.name.getFullText().trim()}.${props.name}`,
+        })
+      : props.name;
+
+  const get_name = (symbol: ts.Symbol): string => {
+    const parent = symbol.getDeclarations()?.[0]?.parent;
+    return parent
+      ? explore_name({
+          node: parent,
+          name: 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/internal/metadata/IMetadataIteratorProps.ts

@@ -1,17 +1,17 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-
-export interface IMetadataIteratorProps<Type extends ts.Type = ts.Type> {
-  options: MetadataFactory.IOptions;
-  checker: ts.TypeChecker;
-  collection: MetadataCollection;
-  errors: MetadataFactory.IError[];
-  metadata: Metadata;
-  type: Type;
-  explore: MetadataFactory.IExplore;
-  intersected?: boolean;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+
+export interface IMetadataIteratorProps<Type extends ts.Type = ts.Type> {
+  options: MetadataFactory.IOptions;
+  checker: ts.TypeChecker;
+  collection: MetadataCollection;
+  errors: MetadataFactory.IError[];
+  metadata: Metadata;
+  type: Type;
+  explore: MetadataFactory.IExplore;
+  intersected?: boolean;
+}

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: [],
-          }),
-        ],
-      }),
-    );
-    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: [],
+          }),
+        ],
+      }),
+    );
+    return metadata;
+  };
+}