typia 13.3.0 → 14.0.1

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

@@ -0,0 +1,123 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesNamedTupleMemberTransform verifies a named tuple
+// member's written type reaches the reported dependencies, and that the file
+// consulting it is still declared complete.
+//
+// `[id: Id]` writes its type as plainly as a property annotation does, and the
+// checker interns `type Id = string` as the bare intrinsic, so the written
+// surface is the only thing that can register `id.ts` (samchon/typia#2126). The
+// member is a declaration kind of its own, so it needs its own place in both the
+// surface that walks a written type and the predicate that decides whether a
+// file may be declared on the strength of one — a kind in the second without the
+// first is exactly an over-declaration (samchon/typia#2357).
+//
+//  1. Build a project where `a.ts` validates a tuple alias whose first member is
+//     named and typed `Id`, beside an alias the tuple never uses.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `src/id.ts` and that `a.ts` is
+//     declared complete, so the narrowed bound is the one carrying it.
+//  4. Assert it omits `src/unused.ts`, which no consulted member names.
+func TestProjectDependenciesNamedTupleMemberTransform(t *testing.T) {
+  project := projectDependenciesNamedTupleMemberProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  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/pair.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the declaring file src/pair.ts: %v", entries)
+  }
+  if !found["src/id.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain src/id.ts, which the named tuple member's type names: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/unused.ts, which no consulted member names: %v", entries)
+  }
+  declared := false
+  for _, key := range envelope.DependenciesComplete {
+    if key == "src/a.ts" {
+      declared = true
+    }
+  }
+  if !declared {
+    t.Fatalf("src/a.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesNamedTupleMemberProject(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-named-tuple-member-")
+  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":      projectDependenciesNamedTupleMemberSourceA,
+    "pair.ts":   projectDependenciesNamedTupleMemberSourcePair,
+    "id.ts":     projectDependenciesNamedTupleMemberSourceId,
+    "unused.ts": projectDependenciesNamedTupleMemberSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesNamedTupleMemberSourceA = `import typia from "typia";
+
+import { Pair } from "./pair";
+
+export const check = (input: unknown) => typia.is<Pair>(input);
+`
+
+const projectDependenciesNamedTupleMemberSourcePair = `import { Id } from "./id";
+import { Unused } from "./unused";
+
+export type Pair = [id: Id, count: number];
+
+export type Spare = [label: Unused];
+`
+
+const projectDependenciesNamedTupleMemberSourceId = `export type Id = string;
+`
+
+const projectDependenciesNamedTupleMemberSourceUnused = `export type Unused = string;
+`

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

@@ -0,0 +1,141 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesQualifiedBarrelTransform verifies a QUALIFIED type
+// reference reports the barrel that selected its namespace half, not only the
+// module declaring its terminus.
+//
+// `TestProjectDependenciesBarrelReexportTransform` pins the bare spelling, and
+// it works because the checker answers `Alpha` with the local import alias, whose
+// path metadataDependency_touchPath walks. `Kind.A` is answered with the enum
+// member instead -- not an alias, no path to walk -- so the barrel between the
+// caller and the enum went unreported while its value went straight into the
+// validator as `"alpha" === input.kind`. Re-pointing that barrel at another enum
+// changed the emitted constant with nothing left to invalidate the file
+// (samchon/typia#2126, samchon/typia#2357).
+//
+//  1. Build a project where `main.ts` validates `Doc`, whose member type is
+//     `Kind.A` for a `Kind` imported from `barrel.ts`, which re-exports it from
+//     `kind.ts` and also re-exports an unconsumed `Unused` from `unused.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert the emitted validator compares against the enum member's value, so
+//     the fixture really does read `kind.ts` into its output.
+//  4. Assert `dependencies["src/main.ts"]` contains `src/barrel.ts` and
+//     `src/kind.ts`, and that `src/main.ts` is declared complete.
+//  5. Assert it omits `src/unused.ts`, the sibling the reference never traverses.
+func TestProjectDependenciesQualifiedBarrelTransform(t *testing.T) {
+  project := projectDependenciesQualifiedBarrelProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  if text := envelope.TypeScript["src/main.ts"]; !strings.Contains(text, `"alpha"`) {
+    t.Fatalf("the validator must compare against the enum member's value, so the fixture reads kind.ts into its output, got:\n%s", text)
+  }
+  entries := envelope.Dependencies["src/main.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/kind.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/kind.ts, which declares the member the type names: %v", entries)
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/barrel.ts, which selects the enum the qualified name reads: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/main.ts must not contain src/unused.ts, a sibling the reference never traverses: %v", entries)
+  }
+  declared := false
+  for _, key := range envelope.DependenciesComplete {
+    if key == "src/main.ts" {
+      declared = true
+    }
+  }
+  if !declared {
+    t.Fatalf("src/main.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesQualifiedBarrelProject(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-qualified-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{
+    "main.ts":   projectDependenciesQualifiedBarrelSourceMain,
+    "doc.ts":    projectDependenciesQualifiedBarrelSourceDoc,
+    "barrel.ts": projectDependenciesQualifiedBarrelSourceBarrel,
+    "kind.ts":   projectDependenciesQualifiedBarrelSourceKind,
+    "unused.ts": projectDependenciesQualifiedBarrelSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesQualifiedBarrelSourceMain = `import typia from "typia";
+
+import { Doc } from "./doc";
+
+export const check = (input: unknown) => typia.is<Doc>(input);
+`
+
+const projectDependenciesQualifiedBarrelSourceDoc = `import { Kind } from "./barrel";
+
+export interface Doc {
+  kind: Kind.A;
+}
+`
+
+const projectDependenciesQualifiedBarrelSourceBarrel = `export { Kind } from "./kind";
+export { Unused } from "./unused";
+`
+
+const projectDependenciesQualifiedBarrelSourceKind = `export enum Kind {
+  A = "alpha",
+  B = "beta",
+}
+`
+
+const projectDependenciesQualifiedBarrelSourceUnused = `export enum Unused {
+  C = "gamma",
+}
+`

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

@@ -0,0 +1,127 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesTypeParameterDefaultTransform verifies an interface's
+// type-parameter default reports the file its alias comes from.
+//
+// `typia.is<Wrapper>()` over `interface Wrapper<T = Id>` validates whatever `Id`
+// is, and the checker interns `type Id = string` as the bare intrinsic, so the
+// resolved type carries no symbol the type graph can follow to `id.ts`
+// (samchon/typia#2126). The equivalent `type AliasWrapper<T = Id> = { v: T }`
+// always reported it, because a `type` alias surfaces its whole node; an
+// interface surfaced only its index signatures, one declaration kind away from
+// the same defect (samchon/typia#2357).
+//
+//  1. Build a project where `a.ts` validates `Wrapper` from `wrapper.ts`, whose
+//     type parameter defaults to `Id` from `id.ts`, and where the same file
+//     declares a second interface defaulting to `Unused` from `unused.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `src/id.ts`, and that `a.ts`
+//     is declared complete so the narrowed bound is the one that carries it.
+//  4. Assert it omits `src/unused.ts`, whose interface the call never reaches.
+func TestProjectDependenciesTypeParameterDefaultTransform(t *testing.T) {
+  project := projectDependenciesTypeParameterDefaultProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  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/wrapper.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the declaring file src/wrapper.ts: %v", entries)
+  }
+  if !found["src/id.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain src/id.ts, which the type-parameter default names: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/unused.ts, which no consulted type reaches: %v", entries)
+  }
+  declared := false
+  for _, key := range envelope.DependenciesComplete {
+    if key == "src/a.ts" {
+      declared = true
+    }
+  }
+  if !declared {
+    t.Fatalf("src/a.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesTypeParameterDefaultProject(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-type-parameter-default-")
+  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":       projectDependenciesTypeParameterDefaultSourceA,
+    "wrapper.ts": projectDependenciesTypeParameterDefaultSourceWrapper,
+    "id.ts":      projectDependenciesTypeParameterDefaultSourceId,
+    "unused.ts":  projectDependenciesTypeParameterDefaultSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesTypeParameterDefaultSourceA = `import typia from "typia";
+
+import { Wrapper } from "./wrapper";
+
+export const check = (input: unknown) => typia.is<Wrapper>(input);
+`
+
+const projectDependenciesTypeParameterDefaultSourceWrapper = `import { Id } from "./id";
+import { Unused } from "./unused";
+
+export interface Wrapper<T = Id> {
+  value: T;
+}
+
+export interface Spare<T = Unused> {
+  value: T;
+}
+`
+
+const projectDependenciesTypeParameterDefaultSourceId = `export type Id = string;
+`
+
+const projectDependenciesTypeParameterDefaultSourceUnused = `export type Unused = number;
+`

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

@@ -34,7 +34,9 @@ func TestTemplateLiteralTypeTagsTransform(t *testing.T) {
   if code != 0 {
     t.Fatalf("template literal tags transform failed: code=%d stderr=\n%s", code, errText)
   }
-  if !strings.Contains(out, "length <= 30") || !strings.Contains(out, "RegExp(/^prefix(.*)postfix$/)") {
+  if !strings.Contains(out, `require("typia/lib/internal/_stringLength")`) ||
+    !strings.Contains(out, "._stringLength(input) <= 30") ||
+    !strings.Contains(out, "RegExp(/^prefix(.*)postfix$/)") {
     t.Fatalf("emitted checker should combine the template pattern with its tags:\n%s", out)
   }
   templateLiteralTypeTagsRunRuntimeCases(t, project, out)