@nestia/core 10.0.1 → 11.0.0-dev.20260305

package/src/programmers/http/HttpIsQuerifyProgrammer.ts

@@ -1,75 +1,77 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpIsQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock([
-        StatementFactory.constant({
-          name: "is",
-          value: IsProgrammer.write({
-            config: {
-              equals: false,
-            },
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createConditionalExpression(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("is"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("stringify"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createNull(),
-          ),
-        ),
-      ]),
-    );
-}
+import {
+  ITypiaContext,
+  IdentifierFactory,
+  IsProgrammer,
+  StatementFactory,
+} from "@typia/core";
+import ts from "typescript";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpIsQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "is",
+          value: IsProgrammer.write({
+            config: {
+              equals: false,
+            },
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("is"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            undefined,
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("stringify"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            undefined,
+            ts.factory.createNull(),
+          ),
+        ),
+      ]),
+    );
+}

package/src/programmers/http/HttpQuerifyProgrammer.ts

@@ -1,108 +1,110 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { FunctionProgrammer } from "typia/lib/programmers/helpers/FunctionProgrammer";
-import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-export namespace HttpQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction => {
-    // GET OBJECT TYPE
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate: HttpQueryProgrammer.validate,
-      },
-      type: props.type,
-      collection,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: functor.method,
-        errors: result.errors,
-      });
-
-    const object: MetadataObject = result.data.objects[0]!;
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock(
-        [
-          ...functor.declare(),
-          StatementFactory.constant({
-            name: "output",
-            value: ts.factory.createNewExpression(
-              ts.factory.createIdentifier("URLSearchParams"),
-              undefined,
-              [],
-            ),
-          }),
-          ...object.type.properties.map((p) =>
-            ts.factory.createExpressionStatement(
-              decode(p.key.constants[0]!.values[0].value as string)(p.value),
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("output"),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  const decode =
-    (key: string) =>
-    (value: Metadata): ts.CallExpression =>
-      !!value.arrays.length
-        ? ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              IdentifierFactory.access(
-                ts.factory.createIdentifier("input"),
-                key,
-              ),
-              "forEach",
-            ),
-            undefined,
-            [
-              ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("elem")],
-                undefined,
-                undefined,
-                append(key)(ts.factory.createIdentifier("elem")),
-              ),
-            ],
-          )
-        : append(key)(
-            IdentifierFactory.access(ts.factory.createIdentifier("input"), key),
-          );
-
-  const append = (key: string) => (elem: ts.Expression) =>
-    ts.factory.createCallExpression(
-      IdentifierFactory.access(ts.factory.createIdentifier("output"), "append"),
-      undefined,
-      [ts.factory.createStringLiteral(key), elem],
-    );
-}
+import {
+  FunctionProgrammer,
+  HttpQueryProgrammer,
+  ITypiaContext,
+  IdentifierFactory,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataObject,
+  MetadataSchema,
+  StatementFactory,
+  TransformerError,
+} from "@typia/core";
+import ts from "typescript";
+
+export namespace HttpQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction => {
+    // GET OBJECT TYPE
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const storage: MetadataCollection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: HttpQueryProgrammer.validate,
+      },
+      type: props.type,
+      components: storage,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: functor.method,
+        errors: result.errors,
+      });
+
+    const object: MetadataObject = result.data.objects[0]!;
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock(
+        [
+          ...functor.declare(),
+          StatementFactory.constant({
+            name: "output",
+            value: ts.factory.createNewExpression(
+              ts.factory.createIdentifier("URLSearchParams"),
+              undefined,
+              [],
+            ),
+          }),
+          ...object.type.properties.map((p) =>
+            ts.factory.createExpressionStatement(
+              decode(p.key.constants[0]!.values[0]!.value as string)(p.value),
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("output"),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  const decode =
+    (key: string) =>
+    (value: MetadataSchema): ts.CallExpression =>
+      !!value.arrays.length
+        ? ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              IdentifierFactory.access(
+                ts.factory.createIdentifier("input"),
+                key,
+              ),
+              "forEach",
+            ),
+            undefined,
+            [
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("elem")],
+                undefined,
+                undefined,
+                append(key)(ts.factory.createIdentifier("elem")),
+              ),
+            ],
+          )
+        : append(key)(
+            IdentifierFactory.access(ts.factory.createIdentifier("input"), key),
+          );
+
+  const append = (key: string) => (elem: ts.Expression) =>
+    ts.factory.createCallExpression(
+      IdentifierFactory.access(ts.factory.createIdentifier("output"), "append"),
+      undefined,
+      [ts.factory.createStringLiteral(key), elem],
+    );
+}

package/src/programmers/http/HttpValidateQuerifyProgrammer.ts

@@ -1,76 +1,78 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpValidateQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock([
-        StatementFactory.constant({
-          name: "validate",
-          value: ValidateProgrammer.write({
-            config: {
-              equals: false,
-            },
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: true,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "query",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "output",
-          value: ts.factory.createCallExpression(
-            ts.factory.createIdentifier("query"),
-            undefined,
-            [ts.factory.createIdentifier("input")],
-          ),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createAsExpression(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("validate"),
-              undefined,
-              [ts.factory.createIdentifier("output")],
-            ),
-            ts.factory.createTypeReferenceNode("any"),
-          ),
-        ),
-      ]),
-    );
-}
+import {
+  ITypiaContext,
+  IdentifierFactory,
+  StatementFactory,
+  ValidateProgrammer,
+} from "@typia/core";
+import ts from "typescript";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpValidateQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "validate",
+          value: ValidateProgrammer.write({
+            config: {
+              equals: false,
+            },
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: true,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "query",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "output",
+          value: ts.factory.createCallExpression(
+            ts.factory.createIdentifier("query"),
+            undefined,
+            [ts.factory.createIdentifier("input")],
+          ),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createAsExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("validate"),
+              undefined,
+              [ts.factory.createIdentifier("output")],
+            ),
+            ts.factory.createTypeReferenceNode("any"),
+          ),
+        ),
+      ]),
+    );
+}

package/src/programmers/internal/CoreMetadataUtil.ts

@@ -1,21 +1,21 @@
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-export namespace CoreMetadataUtil {
-  export const atomics = (
-    meta: Metadata,
-  ): Set<"boolean" | "bigint" | "number" | "string"> =>
-    new Set([
-      ...meta.atomics.map((a) => a.type),
-      ...meta.constants.map((c) => c.type),
-      ...(meta.templates.length ? (["string"] as const) : []),
-    ]);
-
-  export const isUnion = (meta: Metadata): boolean =>
-    atomics(meta).size +
-      meta.arrays.length +
-      meta.tuples.length +
-      meta.natives.length +
-      meta.maps.length +
-      meta.objects.length >
-    1;
-}
+import { MetadataSchema } from "@typia/core";
+
+export namespace CoreMetadataUtil {
+  export const atomics = (
+    meta: MetadataSchema,
+  ): Set<"boolean" | "bigint" | "number" | "string"> =>
+    new Set([
+      ...meta.atomics.map((a) => a.type),
+      ...meta.constants.map((c) => c.type),
+      ...(meta.templates.length ? (["string"] as const) : []),
+    ]);
+
+  export const isUnion = (meta: MetadataSchema): boolean =>
+    atomics(meta).size +
+      meta.arrays.length +
+      meta.tuples.length +
+      meta.natives.length +
+      meta.maps.length +
+      meta.objects.length >
+    1;
+}

package/src/transform.ts

@@ -1,35 +1,35 @@
-import ts from "typescript";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
-import { FileTransformer } from "./transformers/FileTransformer";
-
-export const transform = (
-  program: ts.Program,
-  options: INestiaTransformOptions | undefined,
-  extras: ITypiaContext["extras"],
-): ts.TransformerFactory<ts.SourceFile> => {
-  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
-  const strict: boolean =
-    compilerOptions.strictNullChecks !== undefined
-      ? !!compilerOptions.strictNullChecks
-      : !!compilerOptions.strict;
-  if (strict === false)
-    extras.addDiagnostic({
-      category: ts.DiagnosticCategory.Error,
-      code: "(@nestia/core)" as any,
-      file: undefined,
-      start: undefined,
-      length: undefined,
-      messageText: "strict mode is required.",
-    });
-  return FileTransformer.transform({
-    program,
-    compilerOptions,
-    checker: program.getTypeChecker(),
-    printer: ts.createPrinter(),
-    options: options ?? {},
-    extras,
-  });
-};
-export default transform;
+import { ITypiaContext } from "@typia/core";
+import ts from "typescript";
+
+import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
+import { FileTransformer } from "./transformers/FileTransformer";
+
+export const transform = (
+  program: ts.Program,
+  options: INestiaTransformOptions | undefined,
+  extras: ITypiaContext["extras"],
+): ts.TransformerFactory<ts.SourceFile> => {
+  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
+  const strict: boolean =
+    compilerOptions.strictNullChecks !== undefined
+      ? !!compilerOptions.strictNullChecks
+      : !!compilerOptions.strict;
+  if (strict === false)
+    extras.addDiagnostic({
+      category: ts.DiagnosticCategory.Error,
+      code: "(@nestia/core)" as any,
+      file: undefined,
+      start: undefined,
+      length: undefined,
+      messageText: "strict mode is required.",
+    });
+  return FileTransformer.transform({
+    program,
+    compilerOptions,
+    checker: program.getTypeChecker(),
+    printer: ts.createPrinter(),
+    options: options ?? {},
+    extras,
+  });
+};
+export default transform;