typia 13.0.0-dev.20260427-2 → 13.0.0-dev.20260430

package/native/transform/internal/GenericTransformer.go

@@ -0,0 +1,235 @@
+package internal
+
+import (
+	"encoding/json"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type genericTransformerNamespace struct{}
+
+var GenericTransformer = genericTransformerNamespace{}
+
+type ITransformProps struct {
+	Context    nativecontext.ITypiaContext
+	Modulo     *shimast.Node
+	Expression *shimast.CallExpression
+}
+
+type TransformerError struct {
+	Code    string
+	Message string
+}
+
+func NewTransformerError(props TransformerError_IProps) *TransformerError {
+	return &TransformerError{
+		Code:    props.Code,
+		Message: props.Message,
+	}
+}
+
+func (err *TransformerError) Error() string {
+	return err.Message
+}
+
+type TransformerError_IProps struct {
+	Code    string
+	Message string
+}
+
+type TransformerError_MetadataFactory_IError struct {
+	Name     string
+	Explore  TransformerError_MetadataFactory_IExplore
+	Messages []string
+}
+
+type TransformerError_MetadataFactory_IExplore struct {
+	Object    *nativemetadata.MetadataObjectType
+	Property  any
+	Parameter any
+	Output    bool
+}
+
+func TransformerError_from(props struct {
+	Code   string
+	Errors []TransformerError_MetadataFactory_IError
+}) *TransformerError {
+	lines := make([]string, 0, len(props.Errors))
+	for _, err := range props.Errors {
+		subject := ""
+		if err.Explore.Object != nil {
+			subject = transformerError_join(err.Explore.Object, err.Explore.Property)
+		}
+		middle := ""
+		if err.Explore.Parameter != nil {
+			middle = "(parameter: " + transformerError_json(err.Explore.Parameter) + ")"
+		} else if err.Explore.Output {
+			middle = "(return type)"
+		}
+		typ := err.Name
+		if subject != "" {
+			typ = subject + ": " + typ
+		}
+		messages := make([]string, 0, len(err.Messages))
+		for _, msg := range err.Messages {
+			messages = append(messages, "  - "+msg)
+		}
+		lines = append(lines, "- "+typ+middle+"\n"+strings.Join(messages, "\n"))
+	}
+	return NewTransformerError(TransformerError_IProps{
+		Code:    props.Code,
+		Message: "unsupported type detected\n\n" + strings.Join(lines, "\n\n"),
+	})
+}
+
+func transformerError_join(object *nativemetadata.MetadataObjectType, key any) string {
+	if key == nil {
+		return object.Name
+	}
+	if _, ok := key.(map[string]any); ok {
+		return object.Name + "[key]"
+	}
+	if str, ok := key.(string); ok {
+		if transformerError_variable(str) {
+			return object.Name + "." + str
+		}
+		return object.Name + "[" + transformerError_json(str) + "]"
+	}
+	return object.Name + "[key]"
+}
+
+func transformerError_variable(str string) bool {
+	if str == "" {
+		return false
+	}
+	for i, ch := range str {
+		if i == 0 {
+			if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ch == '_' || ch == '$' {
+				continue
+			}
+			return false
+		}
+		if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ('0' <= ch && ch <= '9') || ch == '_' || ch == '$' {
+			continue
+		}
+		return false
+	}
+	return true
+}
+
+func transformerError_json(value any) string {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return "null"
+	}
+	return string(data)
+}
+
+type GenericTransformer_IProps struct {
+	ITransformProps
+	Method string
+	Write  func(props nativecontext.IProgrammerProps) *shimast.Node
+}
+
+var genericTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (genericTransformerNamespace) Scalar(props GenericTransformer_IProps) *shimast.Node {
+	if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) == 0 {
+		panic(NewTransformerError(TransformerError_IProps{
+			Code:    "typia." + props.Method,
+			Message: "no input value.",
+		}))
+	}
+
+	var typ = props.Context.Checker.GetTypeAtLocation(props.Expression.Arguments.Nodes[0])
+	var node *shimast.Node = props.Expression.Arguments.Nodes[0]
+	generic := false
+	if props.Expression.TypeArguments != nil && len(props.Expression.TypeArguments.Nodes) != 0 {
+		node = props.Expression.TypeArguments.Nodes[0]
+		typ = props.Context.Checker.GetTypeFromTypeNode(node)
+		generic = true
+	}
+	if typ != nil && typ.IsTypeParameter() {
+		panic(NewTransformerError(TransformerError_IProps{
+			Code:    "typia." + props.Method,
+			Message: "non-specified generic argument.",
+		}))
+	}
+
+	name := ""
+	if generic {
+		name = genericTransformer_node_text(node)
+	} else {
+		name = genericTransformer_getTypeName(genericTransformer_getTypeNameProps{
+			Context: props.Context,
+			Type:    typ,
+			Node:    node,
+		})
+	}
+	return genericTransformer_factory.NewCallExpression(
+		props.Write(nativecontext.IProgrammerProps{
+			Context: props.Context,
+			Modulo:  props.Modulo,
+			Type:    typ,
+			Name:    &name,
+		}),
+		nil,
+		nil,
+		props.Expression.Arguments,
+		shimast.NodeFlagsNone,
+	)
+}
+
+func (genericTransformerNamespace) Factory(props GenericTransformer_IProps) *shimast.Node {
+	if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+		panic(NewTransformerError(TransformerError_IProps{
+			Code:    "typia." + props.Method,
+			Message: "generic argument is not specified.",
+		}))
+	}
+	node := props.Expression.TypeArguments.Nodes[0]
+	typ := props.Context.Checker.GetTypeFromTypeNode(node)
+	if typ != nil && typ.IsTypeParameter() {
+		panic(NewTransformerError(TransformerError_IProps{
+			Code:    "typia." + props.Method,
+			Message: "non-specified generic argument.",
+		}))
+	}
+	name := genericTransformer_node_text(node)
+	var init *shimast.Node
+	if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) != 0 {
+		init = props.Expression.Arguments.Nodes[0]
+	}
+	return props.Write(nativecontext.IProgrammerProps{
+		Context: props.Context,
+		Modulo:  props.Modulo,
+		Type:    typ,
+		Name:    &name,
+		Init:    init,
+	})
+}
+
+func genericTransformer_node_text(node *shimast.Node) string {
+	if node == nil {
+		return ""
+	}
+	return strings.TrimSpace(shimscanner.GetTextOfNode(node))
+}
+
+type genericTransformer_getTypeNameProps struct {
+	Context nativecontext.ITypiaContext
+	Type    *shimchecker.Type
+	Node    *shimast.Node
+}
+
+func genericTransformer_getTypeName(props genericTransformer_getTypeNameProps) string {
+	if props.Context.Checker == nil || props.Type == nil {
+		return ""
+	}
+	return props.Context.Checker.TypeToString(props.Type)
+}

package/native/transform/transform.go

@@ -0,0 +1,50 @@
+package transform
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+)
+
+type TransformFactory func(file *shimast.SourceFile) *shimast.SourceFile
+
+func Transform(program *driver.Program, options *nativecontext.ITransformOptions, extras nativecontext.ITypiaContext_Extras) TransformFactory {
+	compilerOptions := transform_compilerOptions(program)
+	if transform_strict(compilerOptions) == false && extras.AddDiagnostic != nil {
+		extras.AddDiagnostic(&shimast.Diagnostic{})
+	}
+	opt := nativecontext.ITransformOptions{}
+	if options != nil {
+		opt = *options
+	}
+	return TransformFactory(FileTransformer.Transform(FileTransformer_IEnvironments{
+		Program:         program,
+		CompilerOptions: compilerOptions,
+		Checker:         transform_checker(program),
+		Printer:         nil,
+		Options:         opt,
+		Extras:          extras,
+	})(nil))
+}
+
+func transform_compilerOptions(program *driver.Program) *shimcore.CompilerOptions {
+	if program == nil || program.ParsedConfig == nil || program.ParsedConfig.ParsedConfig == nil {
+		return nil
+	}
+	return program.ParsedConfig.ParsedConfig.CompilerOptions
+}
+
+func transform_checker(program *driver.Program) any {
+	if program == nil {
+		return nil
+	}
+	return program.Checker
+}
+
+func transform_strict(options *shimcore.CompilerOptions) bool {
+	if options == nil {
+		return true
+	}
+	return options.GetStrictOptionValue(options.StrictNullChecks)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.0.0-dev.20260427-2",
+  "version": "13.0.0-dev.20260430",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -42,21 +42,8 @@
     "inquirer": "^8.2.5",
     "package-manager-detector": "^0.2.0",
     "randexp": "^0.5.3",
-    "ttsc": "^0.4.4",
-    "@typia/interface": "^13.0.0-dev.20260427-2",
-    "@typia/utils": "^13.0.0-dev.20260427-2"
-  },
-  "peerDependencies": {
-    "@typescript/native-preview": ">=7.0.0-dev.20260420.1"
-  },
-  "optionalDependencies": {
-    "@typia/linux-arm": "^13.0.0-dev.20260427-2",
-    "@typia/linux-arm64": "^13.0.0-dev.20260427-2",
-    "@typia/darwin-x64": "^13.0.0-dev.20260427-2",
-    "@typia/darwin-arm64": "^13.0.0-dev.20260427-2",
-    "@typia/win32-arm64": "^13.0.0-dev.20260427-2",
-    "@typia/linux-x64": "^13.0.0-dev.20260427-2",
-    "@typia/win32-x64": "^13.0.0-dev.20260427-2"
+    "@typia/interface": "^13.0.0-dev.20260430",
+    "@typia/utils": "^13.0.0-dev.20260430"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -65,7 +52,7 @@
     "@types/node": "^25.3.0",
     "@typescript-eslint/eslint-plugin": "^8.1.0",
     "@typescript-eslint/parser": "^8.1.0",
-    "@typescript/native-preview": "7.0.0-dev.20260425.1",
+    "@typescript/native-preview": "7.0.0-dev.20260429.1",
     "chalk": "^4.0.0",
     "eslint-plugin-deprecation": "^3.0.0",
     "rimraf": "^6.1.2",
@@ -73,14 +60,18 @@
     "rollup-plugin-auto-external": "^2.0.0",
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
-    "tinyglobby": "^0.2.12"
+    "tinyglobby": "^0.2.12",
+    "ttsc": "^0.6.0"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./lib/_virtual/*.mjs",
+    "./lib/internal/*2.mjs"
+  ],
   "files": [
     "README.md",
-    "bin",
     "package.json",
     "lib",
+    "native",
     "src"
   ],
   "keywords": [

package/src/TypeGuardError.ts

@@ -86,6 +86,7 @@ export class TypeGuardError<T = any> extends Error {
     else (this as any).__proto__ = proto;
 
     // ASSIGN MEMBERS
+    this.name = "TypeGuardError";
     this.method = props.method;
     this.path = props.path;
     this.expected = props.expected;

package/src/executable/TypiaGenerateWizard.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
 import { transform } from "ttsc";
 
@@ -111,30 +112,104 @@ export namespace TypiaGenerateWizard {
     });
 
     const cwd = path.dirname(location.project);
+    const binary = resolveTsgoBinary();
     for (const file of files) {
       const relative = path.relative(location.input, file);
       const target = path.join(location.output, relative);
       const output = transform({
+        binary,
         cwd,
         file,
         tsconfig: location.project,
         plugins: [{ transform: "typia/lib/transform" }],
       });
       await fs.promises.mkdir(path.dirname(target), { recursive: true });
-      await fs.promises.writeFile(
-        target,
-        formatOutput(
-          rewriteExternalRelativeImports({
-            input: location.input,
-            output: location.output,
-            source: file,
-            target,
-            code: output,
-          }),
-        ),
-        "utf8",
+      await fs.promises.writeFile(target, formatOutput(output), "utf8");
+    }
+  }
+
+  function resolveTsgoBinary(): string {
+    const explicit: string | undefined = process.env.TTSC_TSGO_BINARY;
+    if (explicit !== undefined && explicit.length !== 0) {
+      if (path.isAbsolute(explicit) && fs.existsSync(explicit)) {
+        return explicit;
+      }
+      throw new URIError(
+        `Error on TypiaGenerateWizard.generate(): TTSC_TSGO_BINARY must be an existing absolute path: ${explicit}`,
+      );
+    }
+
+    const packageRoot: string = resolveTypiaPackageRoot();
+    const manifest: string | null = resolveFromRoots(
+      "@typescript/native-preview/package.json",
+      [packageRoot, path.resolve(packageRoot, "..", "..")],
+    );
+    if (manifest === null) {
+      throw new URIError(
+        "Error on TypiaGenerateWizard.generate(): unable to resolve @typescript/native-preview from the typia package or workspace root.",
+      );
+    }
+
+    const platform: string = `@typescript/native-preview-${process.platform}-${process.arch}`;
+    const platformManifest: string = createRequire(manifest).resolve(
+      `${platform}/package.json`,
+    );
+    const binary: string = path.join(
+      path.dirname(platformManifest),
+      "lib",
+      process.platform === "win32" ? "tsgo.exe" : "tsgo",
+    );
+    if (fs.existsSync(binary) === false) {
+      throw new URIError(
+        `Error on TypiaGenerateWizard.generate(): TypeScript-Go executable not found: ${binary}`,
       );
     }
+    return binary;
+  }
+
+  function resolveTypiaPackageRoot(): string {
+    const current: string = path.resolve(__dirname);
+    for (const directory of [
+      path.resolve(current, "..", ".."),
+      path.resolve(current, ".."),
+    ]) {
+      const file: string = path.join(directory, "package.json");
+      if (fs.existsSync(file) === false) {
+        continue;
+      }
+      try {
+        const pack = JSON.parse(fs.readFileSync(file, "utf8")) as Partial<
+          Record<"name", unknown>
+        >;
+        if (pack.name === "typia") {
+          return directory;
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    const resolved: string | null = resolveFromRoots("typia/package.json", [
+      process.cwd(),
+      current,
+    ]);
+    if (resolved === null) {
+      throw new URIError(
+        "Error on TypiaGenerateWizard.generate(): unable to resolve typia package root.",
+      );
+    }
+    return path.dirname(resolved);
+  }
+
+  function resolveFromRoots(request: string, roots: string[]): string | null {
+    for (const root of roots) {
+      try {
+        return require.resolve(request, { paths: [root] });
+      } catch {
+        continue;
+      }
+    }
+    return null;
   }
 
   async function isDirectory(current: string): Promise<boolean> {
@@ -181,58 +256,6 @@ export namespace TypiaGenerateWizard {
       ? output
       : `// @ts-nocheck\n${output}`;
   }
-
-  function rewriteExternalRelativeImports(props: {
-    input: string;
-    output: string;
-    source: string;
-    target: string;
-    code: string;
-  }): string {
-    return props.code.replace(
-      /(require\s*\(\s*|from\s+|import\s*\(\s*)(["'])(\.[^"']*)\2/g,
-      (full, prefix: string, quote: string, specifier: string) => {
-        const next: string = rewriteRelativeSpecifier({
-          input: props.input,
-          output: props.output,
-          source: props.source,
-          target: props.target,
-          specifier,
-        });
-        return next === specifier ? full : `${prefix}${quote}${next}${quote}`;
-      },
-    );
-  }
-
-  function rewriteRelativeSpecifier(props: {
-    input: string;
-    output: string;
-    source: string;
-    target: string;
-    specifier: string;
-  }): string {
-    const location: string = path.resolve(
-      path.dirname(props.source),
-      props.specifier,
-    );
-    if (isInside(location, props.input)) {
-      return props.specifier;
-    }
-    const relative: string = path
-      .relative(path.dirname(props.target), location)
-      .split(path.sep)
-      .join("/");
-    return relative.startsWith(".") ? relative : `./${relative}`;
-  }
-
-  function isInside(file: string, directory: string): boolean {
-    const relative: string = path.relative(directory, file);
-    return (
-      relative.length === 0 ||
-      (relative.startsWith("..") === false &&
-        path.isAbsolute(relative) === false)
-    );
-  }
 }
 
 const TS_PATTERN = /\.[cm]?tsx?$/;

package/src/executable/generate/ttsc.ts

@@ -10,9 +10,7 @@ const packageRoot = path.resolve(
   "..",
   "..",
 );
-const repoRoot = path.resolve(packageRoot, "..", "..");
-const nativeProject = path.resolve(repoRoot, "packages", "transform", "native");
-const nativeBinary = resolveNativeBinary();
+const nativeProject = path.resolve(packageRoot, "native");
 const nativeEntrypoint = path.resolve(
   nativeProject,
   "cmd",
@@ -23,6 +21,14 @@ const command = process.platform === "win32" ? "go.exe" : "go";
 const invocationCwd = process.cwd();
 const argv = [...process.argv.slice(2)];
 
+if (
+  process.env.TYPIA_TTSC_TRANSFORM_OUTPUT === "ts" &&
+  argv[0] === "transform" &&
+  !argv.some((value) => value === "--output" || value.startsWith("--output="))
+) {
+  argv.push("--output=ts");
+}
+
 if (
   argv.length > 0 &&
   needsCwd(argv[0]!) &&
@@ -31,42 +37,23 @@ if (
   argv.push(`--cwd=${invocationCwd}`);
 }
 
-const hasNativeBinary = fs.existsSync(nativeBinary);
 const hasSourceEntrypoint = fs.existsSync(nativeEntrypoint);
 
-if (!hasNativeBinary && !hasSourceEntrypoint) {
+if (!hasSourceEntrypoint) {
   process.stderr.write(
-    "ttsc-typia: backend is missing. Expected a platform @typia native package, a package-local ttsc-typia-native binary, or packages/transform/native/cmd/ttsc-typia/main.go.\n",
+    "ttsc-typia: backend source is missing. Expected native/cmd/ttsc-typia/main.go inside the typia package.\n",
   );
   process.exitCode = 1;
 } else {
-  if (hasNativeBinary && process.platform !== "win32") {
-    try {
-      const mode = fs.statSync(nativeBinary).mode & 0o777;
-      if ((mode & 0o111) === 0) {
-        fs.chmodSync(nativeBinary, mode | 0o755);
-      }
-    } catch {
-      /* keep the original spawn error path */
-    }
-  }
-  const result = hasNativeBinary
-    ? spawnSync(nativeBinary, argv, {
-        env: process.env,
-        stdio: "inherit",
-        windowsHide: true,
-      })
-    : spawnSync(command, ["run", "./cmd/ttsc-typia", ...argv], {
-        cwd: nativeProject,
-        env: process.env,
-        stdio: "inherit",
-        windowsHide: true,
-      });
+  const result = spawnSync(command, ["run", "./cmd/ttsc-typia", ...argv], {
+    cwd: nativeProject,
+    env: process.env,
+    stdio: "inherit",
+    windowsHide: true,
+  });
   if (result.error) {
     process.stderr.write(
-      hasNativeBinary
-        ? `ttsc-typia: failed to launch prebuilt backend: ${result.error.message}\n`
-        : `ttsc-typia: failed to launch source checkout via ${command}: ${result.error.message}\n`,
+      `ttsc-typia: failed to launch source backend via ${command}: ${result.error.message}\n`,
     );
     process.exitCode = 1;
   } else {
@@ -83,21 +70,3 @@ function needsCwd(commandName: string): boolean {
     commandName === "--project"
   );
 }
-
-function resolveNativeBinary(): string {
-  const name =
-    process.platform === "win32"
-      ? "ttsc-typia-native.exe"
-      : "ttsc-typia-native";
-  const localBinary = path.resolve(packageRoot, "bin", name);
-  if (fs.existsSync(localBinary)) return localBinary;
-  const platformKey = `${process.platform}-${process.arch}`;
-  const optionalRequest = `@typia/${platformKey}/bin/${name}`;
-  try {
-    return require.resolve(optionalRequest, {
-      paths: [packageRoot, process.cwd()],
-    });
-  } catch {
-    return localBinary;
-  }
-}

package/src/internal/_randomInteger.ts

@@ -8,7 +8,8 @@ export const _randomInteger = (schema: OpenApi.IJsonSchema.IInteger) => {
       (schema.maximum === undefined && schema.exclusiveMaximum === undefined
         ? 0
         : (schema.maximum ?? schema.exclusiveMaximum!) - 100);
-  if (schema.exclusiveMinimum !== undefined) minimum++;
+  if (schema.exclusiveMinimum !== undefined)
+    minimum++;
   let maximum: number =
     schema.maximum ??
     schema.exclusiveMaximum ??
@@ -16,7 +17,8 @@ export const _randomInteger = (schema: OpenApi.IJsonSchema.IInteger) => {
       (schema.minimum === undefined && schema.exclusiveMinimum === undefined
         ? 100
         : (schema.minimum ?? schema.exclusiveMinimum!) + 100);
-  if (schema.exclusiveMaximum !== undefined) maximum--;
+  if (schema.exclusiveMaximum !== undefined)
+    maximum--;
   if (minimum > maximum)
     throw new Error("Minimum value is greater than maximum value.");
   return schema.multipleOf === undefined
@@ -42,9 +44,7 @@ const multiple = (p: {
   const minimum = Math.ceil(p.minimum / p.multipleOf) * p.multipleOf;
   const maximum = Math.floor(p.maximum / p.multipleOf) * p.multipleOf;
   if (minimum > maximum)
-    throw new Error(
-      "The range of the integer is smaller than the multipleOf value.",
-    );
+    throw new Error("The range of the integer is smaller than the multipleOf value.");
   const value: number = scalar({
     minimum,
     maximum,

package/src/internal/_validateReport.ts

@@ -2,7 +2,8 @@ import { IValidation } from "@typia/interface";
 
 export const _validateReport = (array: IValidation.IError[]) => {
   const reportable = (path: string): boolean => {
-    if (array.length === 0) return true;
+    if (array.length === 0)
+      return true;
     const last: string = array[array.length - 1]!.path;
     return path.length > last.length || last.substring(0, path.length) !== path;
   };

package/src/llm.ts

@@ -275,7 +275,7 @@ export function schema(): never;
  * @param $defs Shared schema definitions for `$ref` referencing
  * @returns LLM type schema
  */
-export function schema<T, Config extends Partial<ILlmSchema.IConfig> = {}>(
+export function schema<T, Config = {}>(
   $defs: Record<string, ILlmSchema>,
 ): ILlmSchema;