@typia/core 12.0.0-dev.20260225

package/src/factories/StatementFactory.ts

@@ -0,0 +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,
+    );
+}

package/src/factories/TemplateFactory.ts

@@ -0,0 +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;
+  }
+}

package/src/factories/TypeFactory.ts

@@ -0,0 +1,142 @@
+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;
+    aliasTypeArguments?: boolean; // default: true
+  }): 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.aliasTypeArguments !== false
+        ? (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/ValueFactory.ts

@@ -0,0 +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);
+}

package/src/factories/index.ts

@@ -0,0 +1,16 @@
+export * from "./CommentFactory";
+export * from "./ExpressionFactory";
+export * from "./FormatCheatSheet";
+export * from "./IdentifierFactory";
+export * from "./JsonMetadataFactory";
+export * from "./LiteralFactory";
+export * from "./MetadataCommentTagFactory";
+export * from "./MetadataFactory";
+export * from "./MetadataTypeTagFactory";
+export * from "./MetadataTypeTagSchemaFactory";
+export * from "./NumericRangeFactory";
+export * from "./ProtobufFactory";
+export * from "./StatementFactory";
+export * from "./TemplateFactory";
+export * from "./TypeFactory";
+export * from "./ValueFactory";

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

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

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

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

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

@@ -0,0 +1,45 @@
+import { ArrayUtil } from "@typia/utils";
+
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+import { MetadataSchema } from "../../../schemas/metadata/MetadataSchema";
+
+export const emend_metadata_atomics = (meta: MetadataSchema) => {
+  // 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

@@ -0,0 +1,32 @@
+import { ArrayUtil } from "@typia/utils";
+
+import { MetadataAliasType } from "../../../schemas/metadata/MetadataAliasType";
+import { MetadataSchema } from "../../../schemas/metadata/MetadataSchema";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_alias = (
+  props: IMetadataIteratorProps,
+): MetadataAliasType => {
+  // CHECK EXISTENCE
+  const [alias, newbie, closure] = props.components.emplaceAlias(
+    props.checker,
+    props.type,
+    props.type.aliasSymbol!,
+  );
+  ArrayUtil.add(alias.nullables, props.metadata.nullable);
+  if (newbie === false) return alias;
+
+  // CONSTRUCT VALUE TYPE
+  const value: MetadataSchema = explore_metadata({
+    ...props,
+    explore: {
+      ...props.explore,
+      escaped: false,
+      aliased: true,
+    },
+    intersected: false,
+  });
+  closure(value);
+  return alias;
+};

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

@@ -0,0 +1,37 @@
+import { ArrayUtil } from "@typia/utils";
+import ts from "typescript";
+
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+import { MetadataSchema } from "../../../schemas/metadata/MetadataSchema";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { explore_metadata } from "./explore_metadata";
+
+interface IProps extends IMetadataIteratorProps {
+  array: ts.Type;
+}
+
+export const emplace_metadata_array_type = (
+  props: IProps,
+): MetadataArrayType => {
+  // CHECK EXISTENCE
+  const [array, newbie, setValue] = props.components.emplaceArray(
+    props.checker,
+    props.type,
+  );
+  ArrayUtil.add(array.nullables, props.metadata.nullable);
+  if (newbie === false) return array;
+
+  // CONSTRUCT VALUE TYPE
+  const value: MetadataSchema = explore_metadata({
+    ...props,
+    type: props.array.getNumberIndexType()!,
+    explore: {
+      ...props.explore,
+      escaped: false,
+      aliased: false,
+    },
+    intersected: false,
+  });
+  setValue(value);
+  return array;
+};