typia 5.3.12-dev.20240121 → 5.3.12-dev.20240122

package/src/factories/StatementFactory.ts

@@ -1,72 +1,72 @@
-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,
-      ts.factory.createVariableDeclarationList(
-        [
-          ts.factory.createVariableDeclaration(
-            name,
-            undefined,
-            undefined,
-            initializer,
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    );
-
-  export const entry = (key: string) => (value: string) =>
-    ts.factory.createVariableDeclarationList(
-      [
-        ts.factory.createVariableDeclaration(
-          ts.factory.createArrayBindingPattern([
-            ts.factory.createBindingElement(
-              undefined,
-              undefined,
-              ts.factory.createIdentifier(key),
-              undefined,
-            ),
-            ts.factory.createBindingElement(
-              undefined,
-              undefined,
-              ts.factory.createIdentifier(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";
+
+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,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            name,
+            undefined,
+            undefined,
+            initializer,
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+
+  export const entry = (key: string) => (value: string) =>
+    ts.factory.createVariableDeclarationList(
+      [
+        ts.factory.createVariableDeclaration(
+          ts.factory.createArrayBindingPattern([
+            ts.factory.createBindingElement(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier(key),
+              undefined,
+            ),
+            ts.factory.createBindingElement(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier(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,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,15 +1,15 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-
-export namespace MetadataHelper {
-  export const literal_to_metadata = (key: string): Metadata => {
-    const metadata: Metadata = Metadata.initialize();
-    metadata.constants.push(
-      MetadataConstant.create({
-        type: "string",
-        values: [key],
-      }),
-    );
-    return metadata;
-  };
-}
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+
+export namespace MetadataHelper {
+  export const literal_to_metadata = (key: string): Metadata => {
+    const metadata: Metadata = Metadata.initialize();
+    metadata.constants.push(
+      MetadataConstant.create({
+        type: "string",
+        values: [key],
+      }),
+    );
+    return metadata;
+  };
+}

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

@@ -1,37 +1,37 @@
-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) {
-    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.tags ?? [],
-          }),
-      );
-      temp.tags = undefined;
-    }
-  }
-
-  // TEMPLATE
-  if (
-    meta.templates.length &&
-    meta.atomics.find((a) => a.type === "string") !== undefined
-  )
-    meta.templates.splice(0, meta.templates.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) {
+    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.tags ?? [],
+          }),
+      );
+      temp.tags = undefined;
+    }
+  }
+
+  // TEMPLATE
+  if (
+    meta.templates.length &&
+    meta.atomics.find((a) => a.type === "string") !== undefined
+  )
+    meta.templates.splice(0, meta.templates.length);
+};