typia 14.0.6 → 15.0.1

package/native/core/utils/number_util_reads_javascript_number_grammar_test.go

@@ -0,0 +1,147 @@
+package utils
+
+import (
+  "math"
+  "testing"
+)
+
+// TestNumberUtilReadsJavaScriptNumberGrammar verifies NumberUtil.Read against
+// JavaScript's `Number()`.
+//
+// Tag values and JSDoc extensions are TypeScript source, so the grammar that
+// reads them is JavaScript's StringNumericLiteral. The expectations below are
+// what `Number(text)` returns in JavaScript (samchon/typia#2442), not what the
+// Go float parser accepts; the Go-only spellings (`NaN`, `Inf`, `0x1p4`,
+// `1_000`) are the cases that used to leak through. Text without digits is the
+// one deliberate difference: `Number("")` is 0, but it names no number here.
+//
+//  1. Read decimal, signed, exponent, and point-edge spellings.
+//  2. Read hexadecimal, octal, and binary integers, and reject signed ones.
+//  3. Classify `Infinity`, overflow, and underflow by finiteness.
+//  4. Reject Go-only spellings, separators, and empty or blank text.
+//  5. Spell values back exactly as JavaScript's `String()` does.
+//  6. Read integer spellings exactly, beyond double precision.
+func TestNumberUtilReadsJavaScriptNumberGrammar(t *testing.T) {
+  finite := func(value float64) NumberUtil_Reading {
+    return NumberUtil_Reading{Value: value, Numeric: true, Finite: true}
+  }
+  infinite := func(sign int) NumberUtil_Reading {
+    return NumberUtil_Reading{Value: math.Inf(sign), Numeric: true, Finite: false}
+  }
+  invalid := NumberUtil_Reading{}
+  for _, item := range []struct {
+    text     string
+    expected NumberUtil_Reading
+  }{
+    // Decimal notation, including every point and sign edge `Number()` admits.
+    {"0", finite(0)},
+    {"3", finite(3)},
+    {"-2.5", finite(-2.5)},
+    {"+5", finite(5)},
+    {".5", finite(0.5)},
+    {"5.", finite(5)},
+    {"1e3", finite(1000)},
+    {"1E-3", finite(0.001)},
+    {"-0", finite(0)},
+    {"  12\t", finite(12)},
+    {"\u00a012\u2028", finite(12)},
+    {"007", finite(7)},
+    // Non-decimal integers: unsigned only, any letter case in the prefix.
+    {"0x10", finite(16)},
+    {"0XfF", finite(255)},
+    {"0o7", finite(7)},
+    {"0b101", finite(5)},
+    {"-0x10", invalid},
+    {"+0x10", invalid},
+    {"0o8", invalid},
+    {"0b2", invalid},
+    {"0x", invalid},
+    // Non-finite values are numeric but not finite.
+    {"Infinity", infinite(1)},
+    {"+Infinity", infinite(1)},
+    {"-Infinity", infinite(-1)},
+    {"1e400", infinite(1)},
+    {"-1e400", infinite(-1)},
+    {"1e-400", finite(0)},
+    // Go-only spellings and separators: NaN in JavaScript.
+    {"NaN", invalid},
+    {"nan", invalid},
+    {"Inf", invalid},
+    {"inf", invalid},
+    {"-inf", invalid},
+    {"infinity", invalid},
+    {"0x1p4", invalid},
+    {"1_000", invalid},
+    {"1e", invalid},
+    {".", invalid},
+    {"1.2.3", invalid},
+    {"12px", invalid},
+    // No digits at all.
+    {"", invalid},
+    {"   ", invalid},
+    {"+", invalid},
+  } {
+    actual := NumberUtil.Read(item.text)
+    if actual != item.expected || math.Signbit(actual.Value) != math.Signbit(item.expected.Value) {
+      t.Fatalf("Read(%q) = %+v, expected %+v", item.text, actual, item.expected)
+    }
+  }
+
+  // String: the oracle is JavaScript's `String(value)`.
+  for _, item := range []struct {
+    value    float64
+    expected string
+  }{
+    {0, "0"},
+    {math.Copysign(0, -1), "0"},
+    {16, "16"},
+    {-2.5, "-2.5"},
+    {0.001, "0.001"},
+    {0.000001, "0.000001"},
+    {1e6, "1000000"},
+    {123456789012345680000, "123456789012345680000"},
+    {1e21, "1e+21"},
+    {1e-7, "1e-7"},
+    {-1e-7, "-1e-7"},
+    {1.23e-18, "1.23e-18"},
+    {1.5e300, "1.5e+300"},
+    {9007199254740993, "9007199254740992"},
+    {math.NaN(), "NaN"},
+    {math.Inf(1), "Infinity"},
+    {math.Inf(-1), "-Infinity"},
+  } {
+    if actual := NumberUtil.String(item.value); actual != item.expected {
+      t.Fatalf("String(%v) = %q, expected %q", item.value, actual, item.expected)
+    }
+  }
+
+  // Integer: exact digits for integer spellings, nothing for the rest.
+  for _, item := range []struct {
+    text     string
+    expected string
+    ok       bool
+  }{
+    {"9007199254740993", "9007199254740993", true},
+    {"-12", "-12", true},
+    {"+5", "5", true},
+    {"007", "7", true},
+    {"-0", "0", true},
+    {" 42 ", "42", true},
+    {"0x10", "16", true},
+    {"0b101", "5", true},
+    {"0o17", "15", true},
+    {"0xffffffffffffffffff", "4722366482869645213695", true},
+    {"1e3", "", false},
+    {"1.0", "", false},
+    {"-0x10", "", false},
+    {"0o8", "", false},
+    {"", "", false},
+    {"Infinity", "", false},
+  } {
+    integer, ok := NumberUtil.Integer(item.text)
+    if ok != item.ok || (ok && integer.String() != item.expected) {
+      t.Fatalf("Integer(%q) = %v, %v; expected %q, %v", item.text, integer, ok, item.expected, item.ok)
+    }
+  }
+
+}

package/native/transform/CallExpressionTransformer.go

@@ -469,6 +469,7 @@ func callExpressionTransformer_createFunctors() map[string]map[string]callExpres
       "structuredOutput": func() callExpressionTransformerTask {
         return nativellmtransformers.LlmStructuredOutputTransformer.Transform
       },
+      "evaluation":  func() callExpressionTransformerTask { return nativellmtransformers.LlmEvaluationTransformer.Transform },
       "parameters":  func() callExpressionTransformerTask { return nativellmtransformers.LlmParametersTransformer.Transform },
       "schema":      func() callExpressionTransformerTask { return nativellmtransformers.LlmSchemaTransformer.Transform },
       "parse":       func() callExpressionTransformerTask { return nativellmtransformers.LlmParseTransformer.Transform },

package/native/transform/FileTransformer.go

@@ -33,6 +33,10 @@ var fileTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 var fileTransformer_jsDocParsingMode sync.Map
 
 func (fileTransformerNamespace) Transform(environments FileTransformer_IEnvironments) func(transformer any) FileTransformer_Type {
+  shared := environments.Extras.Shared
+  if shared == nil {
+    shared = &sync.Map{}
+  }
   return func(transformer any) FileTransformer_Type {
     return func(file *shimast.SourceFile) *shimast.SourceFile {
       if file == nil || file.IsDeclarationFile {
@@ -53,6 +57,7 @@ func (fileTransformerNamespace) Transform(environments FileTransformer_IEnvironm
         Emit:            environments.EmitContext,
         Importer:        importer,
         Extras:          environments.Extras,
+        Shared:          shared,
       }
       _ = transformer
       fileTransformer_checkJsDocParsingMode(context, file)

package/native/transform/features/llm/LlmEvaluationProbabilityDeclarations.go

@@ -0,0 +1,94 @@
+package llm
+
+import (
+  "fmt"
+  "strings"
+  "sync"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+)
+
+func llmEvaluation_cachedDeclarationProbabilityErrors(context nativecontext.ITypiaContext) []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+  if context.Program == nil {
+    return nil
+  }
+  return llmEvaluation_onceDeclarationProbabilityErrors(context.Shared, func() []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+    return llmEvaluation_declarationProbabilityErrors(context.Program.SourceFiles())
+  })
+}
+
+func llmEvaluation_onceDeclarationProbabilityErrors(shared *sync.Map, analyze func() []nativellmprogrammers.LlmEvaluationProgrammer_IError) []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+  if shared == nil {
+    return analyze()
+  }
+  cached, _ := shared.LoadOrStore("llm.evaluation.probability.declarations", sync.OnceValue(analyze))
+  return cached.(func() []nativellmprogrammers.LlmEvaluationProgrammer_IError)()
+}
+
+// Primitive aliases lose their declaration identity when TypeScript resolves
+// them (boolean aliases become the same boolean type). Consequently, no walk
+// of the resolved evaluation type can reliably distinguish a used annotation
+// from an unused one. Validate tag placement syntactically across a program
+// that uses llm.evaluation: only properties and enum members can carry it.
+func llmEvaluation_declarationProbabilityErrors(files []*shimast.SourceFile) []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+  errors := []nativellmprogrammers.LlmEvaluationProgrammer_IError{}
+  for _, file := range files {
+    if file == nil || !strings.Contains(file.Text(), "@probability") {
+      continue
+    }
+    var walk func(*shimast.Node)
+    walk = func(node *shimast.Node) {
+      if node == nil {
+        return
+      }
+      allowed := node.Kind == shimast.KindPropertySignature ||
+        node.Kind == shimast.KindPropertyDeclaration ||
+        node.Kind == shimast.KindGetAccessor ||
+        node.Kind == shimast.KindSetAccessor ||
+        node.Kind == shimast.KindEnumMember
+      if !allowed {
+        for _, doc := range node.JSDoc(nil) {
+          parsed := doc.AsJSDoc()
+          if parsed == nil || parsed.Tags == nil {
+            continue
+          }
+          for _, tag := range parsed.Tags.Nodes {
+            if tag != nil && tag.TagName() != nil && tag.TagName().Text() == "probability" {
+              name := "<anonymous>"
+              if identifier := node.Name(); identifier != nil {
+                switch identifier.Kind {
+                case shimast.KindIdentifier, shimast.KindStringLiteral, shimast.KindNumericLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+                  name = identifier.Text()
+                }
+              }
+              kind := "declaration"
+              switch node.Kind {
+              case shimast.KindTypeAliasDeclaration:
+                kind = "type alias"
+              case shimast.KindInterfaceDeclaration:
+                kind = "interface"
+              case shimast.KindClassDeclaration, shimast.KindClassExpression:
+                kind = "class"
+              case shimast.KindEnumDeclaration:
+                kind = "enum"
+              }
+              errors = append(errors, nativellmprogrammers.LlmEvaluationProgrammer_IError{
+                Accessor: "$input",
+                Message:  fmt.Sprintf("LLM evaluation @probability on %s %s in %s is unsupported; put it on a decision property or enum member.", kind, name, file.FileName()),
+              })
+              break
+            }
+          }
+        }
+      }
+      node.ForEachChild(func(child *shimast.Node) bool {
+        walk(child)
+        return false
+      })
+    }
+    walk(file.AsNode())
+  }
+  return errors
+}

package/native/transform/features/llm/LlmEvaluationProbabilityDeclarations_test.go

@@ -0,0 +1,50 @@
+package llm
+
+import (
+  "sync"
+  "sync/atomic"
+  "testing"
+
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+)
+
+// TestLlmEvaluationDeclarationProbabilityCache verifies one placement scan
+// runs for every transform invocation sharing a program cache.
+//
+// File callbacks can run concurrently and must receive the same diagnostic
+// result without redoing the program-wide scan. A new program gets a new map.
+//
+//  1. Read the result concurrently through one shared map.
+//  2. Require one calculation and identical diagnostics for every reader.
+//  3. Require a fresh map and an uncached call to calculate independently.
+func TestLlmEvaluationDeclarationProbabilityCache(t *testing.T) {
+  var calls atomic.Int32
+  analyze := func() []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+    calls.Add(1)
+    return []nativellmprogrammers.LlmEvaluationProgrammer_IError{{
+      Accessor: "$input",
+      Message:  "unsupported declaration",
+    }}
+  }
+  shared := &sync.Map{}
+  var group sync.WaitGroup
+  for range 16 {
+    group.Add(1)
+    go func() {
+      defer group.Done()
+      errors := llmEvaluation_onceDeclarationProbabilityErrors(shared, analyze)
+      if len(errors) != 1 || errors[0].Message != "unsupported declaration" {
+        t.Errorf("cached diagnostic changed: %+v", errors)
+      }
+    }()
+  }
+  group.Wait()
+  if count := calls.Load(); count != 1 {
+    t.Fatalf("one program must scan once, got %d scans", count)
+  }
+  llmEvaluation_onceDeclarationProbabilityErrors(&sync.Map{}, analyze)
+  llmEvaluation_onceDeclarationProbabilityErrors(nil, analyze)
+  if count := calls.Load(); count != 3 {
+    t.Fatalf("fresh and uncached programs must recalculate, got %d scans", count)
+  }
+}

package/native/transform/features/llm/LlmEvaluationTransformer.go

@@ -0,0 +1,59 @@
+package llm
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type llmEvaluationTransformerNamespace struct{}
+
+var LlmEvaluationTransformer = llmEvaluationTransformerNamespace{}
+
+func (llmEvaluationTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+  top, typ, ok := llmTransformer_type_argument(props, "typia.llm.evaluation")
+  if ok == false {
+    return props.Expression.AsNode()
+  }
+  if typ != nil && typ.IsTypeParameter() {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.evaluation", Message: "non-specified generic argument."}))
+  }
+  metadata := llmTransformer_analyze(llmTransformer_analyzeProps{
+    Context:             props.Context,
+    Type:                typ,
+    Code:                "typia.llm.evaluation",
+    Absorb:              true,
+    StrictObjectMembers: true,
+    Validate: func(struct {
+      Metadata *schemametadata.MetadataSchema
+      Explore  nativefactories.MetadataFactory_IExplore
+      Top      *schemametadata.MetadataSchema
+    }) []string {
+      return nil
+    },
+  })
+  plan, errors := nativellmprogrammers.LlmEvaluationProgrammer.Compose(metadata)
+  errors = append(errors, llmEvaluation_cachedDeclarationProbabilityErrors(props.Context)...)
+  // The placement scan depends on every program source, including files with
+  // no tag today: adding one later must invalidate a cached successful emit.
+  if props.Context.Program != nil && schemametadata.MetadataDependency_active(props.Context.Checker) {
+    for _, file := range props.Context.Program.SourceFiles() {
+      if file != nil {
+        schemametadata.MetadataDependency_touchFile(props.Context.Checker, file.FileName())
+      }
+    }
+  }
+  if len(errors) != 0 {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+      Code:    "typia.llm.evaluation",
+      Message: nativellmprogrammers.LlmEvaluationProgrammer.Message(errors),
+    }))
+  }
+  return nativellmprogrammers.LlmEvaluationProgrammer.Write(nativellmprogrammers.LlmEvaluationProgrammer_IWriteProps{
+    Context:  props.Context,
+    Metadata: metadata,
+    Name:     llmTransformer_type_name(top),
+  }, plan)
+}

package/native/transform/features/llm/LlmSchemaTransformer.go

@@ -68,12 +68,13 @@ func (llmSchemaTransformerNamespace) Transform(props nativetransform.ITransformP
 }
 
 type llmTransformer_analyzeProps struct {
-  Context    nativecontext.ITypiaContext
-  Type       *shimchecker.Type
-  Code       string
-  Absorb     bool
-  Functional bool
-  Validate   func(props struct {
+  Context             nativecontext.ITypiaContext
+  Type                *shimchecker.Type
+  Code                string
+  Absorb              bool
+  Functional          bool
+  StrictObjectMembers bool
+  Validate            func(props struct {
     Metadata *schemametadata.MetadataSchema
     Explore  nativefactories.MetadataFactory_IExplore
     Top      *schemametadata.MetadataSchema
@@ -105,11 +106,13 @@ func llmTransformer_analyze(props llmTransformer_analyzeProps) *schemametadata.M
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
     Checker: props.Context.Checker,
     Options: nativefactories.MetadataFactory_IOptions{
-      Absorb:     props.Absorb,
-      Escape:     true,
-      Constant:   true,
-      Functional: props.Functional,
-      Validate:   props.Validate,
+      Absorb:              props.Absorb,
+      Escape:              true,
+      Constant:            true,
+      Functional:          props.Functional,
+      Methods:             props.StrictObjectMembers,
+      StrictObjectMembers: props.StrictObjectMembers,
+      Validate:            props.Validate,
     },
     Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
       Replace: schemametadata.MetadataCollection_replace,

package/native/transform/features/llm/llm_transformer_entry_coverage_test.go

@@ -4,9 +4,9 @@
 package llm
 
 import (
-	"testing"
+  "testing"
 
-	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 // TestLLMTransformerEntryCoverage exercises LLM transform entrypoints.
@@ -16,33 +16,35 @@ import (
 // guards. Empty transform props visit those entrypoints and recover their guard
 // failures deterministically.
 //
-// 1. Visit schema, parameters, application, and structured-output wrappers.
-// 2. Visit controller and parse/coerce scalar wrappers.
-// 3. Visit create-parse and create-coerce factory wrappers.
-// 4. Recover expected guard panics for every wrapper call.
+//  1. Visit schema, parameters, application, structured-output, and evaluation
+//     wrappers.
+//  2. Visit controller and parse/coerce scalar wrappers.
+//  3. Visit create-parse and create-coerce factory wrappers.
+//  4. Recover expected guard panics for every wrapper call.
 func TestLLMTransformerEntryCoverage(t *testing.T) {
-	props := nativetransform.ITransformProps{}
-	for _, run := range []func(){
-		func() { LlmSchemaTransformer.Transform(props) },
-		func() { LlmParametersTransformer.Transform(props) },
-		func() { LlmApplicationTransformer.Transform(props) },
-		func() { LlmStructuredOutputTransformer.Transform(props) },
-		func() { LlmControllerTransformer.Transform(props) },
-		func() { LlmParseTransformer.Transform(props) },
-		func() { LlmCoerceTransformer.Transform(props) },
-		func() { LlmCreateParseTransformer.Transform(props) },
-		func() { LlmCreateCoerceTransformer.Transform(props) },
-	} {
-		expectLLMPanic(t, run)
-	}
+  props := nativetransform.ITransformProps{}
+  for _, run := range []func(){
+    func() { LlmSchemaTransformer.Transform(props) },
+    func() { LlmParametersTransformer.Transform(props) },
+    func() { LlmApplicationTransformer.Transform(props) },
+    func() { LlmStructuredOutputTransformer.Transform(props) },
+    func() { LlmEvaluationTransformer.Transform(props) },
+    func() { LlmControllerTransformer.Transform(props) },
+    func() { LlmParseTransformer.Transform(props) },
+    func() { LlmCoerceTransformer.Transform(props) },
+    func() { LlmCreateParseTransformer.Transform(props) },
+    func() { LlmCreateCoerceTransformer.Transform(props) },
+  } {
+    expectLLMPanic(t, run)
+  }
 }
 
 func expectLLMPanic(t *testing.T, run func()) {
-	t.Helper()
-	defer func() {
-		if recover() == nil {
-			t.Fatal("expected LLM transformer panic")
-		}
-	}()
-	run()
+  t.Helper()
+  defer func() {
+    if recover() == nil {
+      t.Fatal("expected LLM transformer panic")
+    }
+  }()
+  run()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "14.0.6",
+  "version": "15.0.1",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,8 +43,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^14.0.6",
-    "@typia/utils": "^14.0.6"
+    "@typia/interface": "^15.0.1",
+    "@typia/utils": "^15.0.1"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"