typia 13.1.1 → 13.2.0

package/native/cmd/ttsc-typia/project_dependencies_custom_lib_name_transform_test.go

@@ -0,0 +1,135 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCustomLibNameTransform verifies a project-owned
+// ambient declaration file named `lib.custom.d.ts` appears in the transform
+// envelope's `dependencies`.
+//
+// Default-library exclusion must come from the compiler's own classification,
+// never from a filename pattern: a basename predicate (`lib.*.d.ts`) silently
+// drops a project's own ambient file with that common naming, so its changes
+// never invalidate consumers and persistent bundler caches serve stale
+// validators (samchon/typia#2108). Compiler-owned default libraries must still
+// stay excluded.
+//
+//  1. Build a project where `a.ts` calls `typia.validate<Bee>()` with `Bee`
+//     declared in `b.ts` consuming the ambient `CustomAmbient` interface
+//     declared in `src/lib.custom.d.ts`, plus a `Date` property so the
+//     analysis touches real default libraries.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `src/lib.custom.d.ts`.
+//  4. Assert no compiler-owned default library (virtual `bundled:///` URI or
+//     any value outside the project) leaks into the entry.
+func TestProjectDependenciesCustomLibNameTransform(t *testing.T) {
+  project := projectDependenciesCustomLibNameProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    TypeScript   map[string]string   `json:"typescript"`
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  if len(entries) == 0 {
+    t.Fatalf("dependencies must contain an entry for src/a.ts:\n%s", out)
+  }
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+    if strings.Contains(entry, "://") {
+      t.Fatalf("dependencies must exclude virtual URI sources, got %q in %v", entry, entries)
+    }
+    if filepath.IsAbs(filepath.FromSlash(entry)) || strings.HasPrefix(entry, "../") {
+      t.Fatalf("dependencies must not report files outside the project, got %q in %v", entry, entries)
+    }
+  }
+  if !found["src/lib.custom.d.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the project-owned src/lib.custom.d.ts: %v", entries)
+  }
+  if !found["src/b.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the direct declaration file src/b.ts: %v", entries)
+  }
+}
+
+func projectDependenciesCustomLibNameProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-custom-lib-name-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesCustomLibNameTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts":            projectDependenciesCustomLibNameSourceA,
+    "b.ts":            projectDependenciesCustomLibNameSourceB,
+    "lib.custom.d.ts": projectDependenciesCustomLibNameSourceLib,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCustomLibNameTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`
+
+const projectDependenciesCustomLibNameSourceA = `import typia from "typia";
+
+import { Bee } from "./b";
+
+export const validateBee = (input: unknown) => typia.validate<Bee>(input);
+`
+
+const projectDependenciesCustomLibNameSourceB = `export interface Bee {
+  id: string;
+  when: Date;
+  ambient: CustomAmbient;
+}
+`
+
+const projectDependenciesCustomLibNameSourceLib = `declare interface CustomAmbient {
+  tag: string;
+}
+`

package/native/cmd/ttsc-typia/project_dependencies_default_barrel_transform_test.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesDefaultBarrelTransform verifies a default-export
+// barrel reports the module it forwards to, and never a same-named sibling.
+//
+// A default import binds `default`, not its own local name, so an alias walk
+// that stepped through the local name would look up whatever the barrel happens
+// to export under it — reporting a module the reference never consults and
+// invalidating consumers on edits that cannot reach them. `dependencies` names
+// every file whose edit can change the generated output and ONLY those, so this
+// pins both halves of that invariant on one fixture (samchon/typia#2126).
+//
+//  1. Build a project where `a.ts` validates the default import `Alpha` from
+//     `barrel.ts`, which forwards `default` from `real.ts` while separately
+//     exporting an unrelated NAMED `Alpha` from `unrelated.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `barrel.ts` and `real.ts`.
+//  4. Assert it does NOT contain `unrelated.ts`, whose only tie to the walk is
+//     sharing the local name of the default import.
+func TestProjectDependenciesDefaultBarrelTransform(t *testing.T) {
+  project := projectDependenciesDefaultBarrelProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the default barrel src/barrel.ts: %v", entries)
+  }
+  if !found["src/real.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the forwarded module src/real.ts: %v", entries)
+  }
+  if found["src/unrelated.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/unrelated.ts: the default import never consults the barrel's same-named export: %v", entries)
+  }
+}
+
+func projectDependenciesDefaultBarrelProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-default-barrel-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts":         projectDependenciesDefaultBarrelSourceA,
+    "barrel.ts":    projectDependenciesDefaultBarrelSourceBarrel,
+    "real.ts":      projectDependenciesDefaultBarrelSourceReal,
+    "unrelated.ts": projectDependenciesDefaultBarrelSourceUnrelated,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesDefaultBarrelSourceA = `import typia from "typia";
+
+import Alpha from "./barrel";
+
+export const validateAlpha = (input: unknown) => typia.validate<Alpha>(input);
+`
+
+const projectDependenciesDefaultBarrelSourceBarrel = `export { default } from "./real";
+export { Alpha } from "./unrelated";
+`
+
+const projectDependenciesDefaultBarrelSourceReal = `interface Real {
+  id: string;
+}
+
+export default Real;
+`
+
+const projectDependenciesDefaultBarrelSourceUnrelated = `export interface Alpha {
+  nope: boolean;
+}
+`

package/native/cmd/ttsc-typia/project_dependencies_empty_heritage_transform_test.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesEmptyHeritageTransform verifies heritage targets
+// register as dependencies even when they contribute no property yet.
+//
+// Inherited members carry their declaring file through their property symbols,
+// but a base interface that is currently EMPTY surfaces no symbol at all — and
+// gaining its first property is exactly the change that must invalidate the
+// consumer's cached validator. This pins the explicit `extends` chain walk.
+//
+//  1. Build a project where `main.ts` validates `Doc`, `doc.ts` declares
+//     `Doc extends Empty`, and `empty.ts` declares the empty interface.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/main.ts"]` contains both `src/doc.ts` (the
+//     declaring file) and `src/empty.ts` (the property-less heritage target).
+func TestProjectDependenciesEmptyHeritageTransform(t *testing.T) {
+  project := projectDependenciesEmptyHeritageProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/main.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/doc.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain the declaring file src/doc.ts: %v", entries)
+  }
+  if !found["src/empty.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain the empty heritage target src/empty.ts: %v", entries)
+  }
+}
+
+func projectDependenciesEmptyHeritageProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-empty-heritage-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "main.ts":  projectDependenciesEmptyHeritageMain,
+    "doc.ts":   projectDependenciesEmptyHeritageDoc,
+    "empty.ts": projectDependenciesEmptyHeritageEmpty,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesEmptyHeritageMain = `import typia from "typia";
+
+import { Doc } from "./doc";
+
+export const validateDoc = (input: unknown) => typia.validate<Doc>(input);
+`
+
+const projectDependenciesEmptyHeritageDoc = `import { Empty } from "./empty";
+
+export interface Doc extends Empty {
+  id: string;
+}
+`
+
+const projectDependenciesEmptyHeritageEmpty = `export interface Empty {}
+`

package/native/cmd/ttsc-typia/project_dependencies_envelope_transform_test.go

@@ -0,0 +1,148 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesEnvelopeTransform verifies the project transform
+// envelope reports consulted declaration files per transformed file.
+//
+// The `dependencies` section is what lets the ttsc consumer register a
+// validated type's declaring files with the bundler; without it, persistent
+// caches and watch mode serve stale validators when only the type's own file
+// changes (samchon/typia#2092). This pins the producer contract: direct and
+// transitive declaration files attributed to the call-expression site,
+// nothing attributed to files without typia calls, no self entry, and no
+// default-library noise.
+//
+//  1. Build a project where `a.ts` calls `typia.validate<Bee>()` with `Bee`
+//     declared in `b.ts` referencing `Cee` from `c.ts` through a property type,
+//     plus `d.ts` with no typia call.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains both `src/b.ts` and `src/c.ts`.
+//  4. Assert no entry exists for `src/b.ts`, `src/c.ts`, or `src/d.ts`, the
+//     entry omits `src/a.ts` itself, and no `lib.*.d.ts` value leaks.
+func TestProjectDependenciesEnvelopeTransform(t *testing.T) {
+  project := projectDependenciesEnvelopeProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    TypeScript   map[string]string   `json:"typescript"`
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  if _, ok := envelope.TypeScript["src/a.ts"]; !ok {
+    t.Fatalf("typescript map must contain src/a.ts, got keys of:\n%s", out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  if len(entries) == 0 {
+    t.Fatalf("dependencies must contain an entry for src/a.ts:\n%s", out)
+  }
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+    if entry == "src/a.ts" {
+      t.Fatalf("dependencies of src/a.ts must omit the file itself: %v", entries)
+    }
+    base := filepath.Base(filepath.FromSlash(entry))
+    if strings.HasPrefix(base, "lib.") && strings.HasSuffix(base, ".d.ts") {
+      t.Fatalf("dependencies must exclude default library files, got %q in %v", entry, entries)
+    }
+  }
+  if !found["src/b.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the direct declaration file src/b.ts: %v", entries)
+  }
+  if !found["src/c.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the transitive declaration file src/c.ts: %v", entries)
+  }
+  for _, key := range []string{"src/b.ts", "src/c.ts", "src/d.ts"} {
+    if _, ok := envelope.Dependencies[key]; ok {
+      t.Fatalf("%s has no typia call and must report no dependency entry: %v", key, envelope.Dependencies[key])
+    }
+  }
+}
+
+func projectDependenciesEnvelopeProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-envelope-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts": projectDependenciesEnvelopeSourceA,
+    "b.ts": projectDependenciesEnvelopeSourceB,
+    "c.ts": projectDependenciesEnvelopeSourceC,
+    "d.ts": projectDependenciesEnvelopeSourceD,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesEnvelopeTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`
+
+const projectDependenciesEnvelopeSourceA = `import typia from "typia";
+
+import { Bee } from "./b";
+
+export const validateBee = (input: unknown) => typia.validate<Bee>(input);
+`
+
+const projectDependenciesEnvelopeSourceB = `import { Cee } from "./c";
+
+export interface Bee {
+  id: string;
+  nested: Cee;
+}
+`
+
+const projectDependenciesEnvelopeSourceC = `export interface Cee {
+  value: number;
+}
+`
+
+const projectDependenciesEnvelopeSourceD = `export const plain: number = 42;
+`

package/native/cmd/ttsc-typia/project_dependencies_index_signature_alias_transform_test.go

@@ -0,0 +1,139 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesIndexSignatureAliasTransform verifies an index
+// signature's written key and value aliases register their declaring files.
+//
+// Index signatures carry no property symbol, so the apparent-property walk that
+// registers every ordinary member never sees them; their aliases-of-intrinsics
+// are then collapsed by the checker and leave no trace on the type graph
+// either. Both `[k: string]: Value` and `[k: Key]: string` therefore changed the
+// generated validator with no reported edge to invalidate
+// (samchon/typia#2126). The negative twin pins the boundary: a file reached only
+// from a member the index signature does not consult must stay out.
+//
+//  1. Build a project where `a.ts` validates `Target` from `model.ts`, whose
+//     index signature uses the key alias `Key` (`key.ts`) and the value alias
+//     `Value` (`value.ts`), and whose unrelated property references `Kept`
+//     (`kept.ts`) while a method body alone references `BodyOnly` (`body.ts`).
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `key.ts`, `value.ts`, and
+//     `kept.ts`.
+//  4. Assert it does NOT contain the body-only `body.ts`.
+func TestProjectDependenciesIndexSignatureAliasTransform(t *testing.T) {
+  project := projectDependenciesIndexSignatureAliasProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/value.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the index-signature value alias file src/value.ts: %v", entries)
+  }
+  if !found["src/key.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the index-signature key alias file src/key.ts: %v", entries)
+  }
+  if !found["src/kept.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the property alias file src/kept.ts: %v", entries)
+  }
+  if found["src/body.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain the body-only reference file src/body.ts: %v", entries)
+  }
+}
+
+func projectDependenciesIndexSignatureAliasProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-index-signature-alias-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts":     projectDependenciesIndexSignatureAliasSourceA,
+    "model.ts": projectDependenciesIndexSignatureAliasSourceModel,
+    "key.ts":   projectDependenciesIndexSignatureAliasSourceKey,
+    "value.ts": projectDependenciesIndexSignatureAliasSourceValue,
+    "kept.ts":  projectDependenciesIndexSignatureAliasSourceKept,
+    "body.ts":  projectDependenciesIndexSignatureAliasSourceBody,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesIndexSignatureAliasSourceA = `import typia from "typia";
+
+import { Holder, Target } from "./model";
+
+export const validateTarget = (input: unknown) => typia.validate<Target>(input);
+export const validateHolder = (input: unknown) => typia.validate<Holder>(input);
+`
+
+const projectDependenciesIndexSignatureAliasSourceModel = `import { BodyOnly } from "./body";
+import { Kept } from "./kept";
+import { Key } from "./key";
+import { Value } from "./value";
+
+export interface Target {
+  [key: Key]: Value;
+}
+
+export class Holder {
+  public kept!: Kept;
+
+  public describe(): string {
+    const helper: BodyOnly = { tag: "x" };
+    return helper.tag;
+  }
+}
+`
+
+const projectDependenciesIndexSignatureAliasSourceKey = `export type Key = string;
+`
+
+const projectDependenciesIndexSignatureAliasSourceValue = `export type Value = string;
+`
+
+const projectDependenciesIndexSignatureAliasSourceKept = `export type Kept = number;
+`
+
+const projectDependenciesIndexSignatureAliasSourceBody = `export interface BodyOnly {
+  tag: string;
+}
+`