typia 13.1.19 → 13.2.0

package/src/internal/_randomStringLength.ts

@@ -1,5 +1,9 @@
+import { _randomInteger } from "./_randomInteger";
 import { _randomString } from "./_randomString";
 
+export const _RANDOM_LENGTH_ERROR =
+  "unable to generate a random string satisfying both the format and the length constraints.";
+
 /**
  * Length bounds forwarded to a string format or pattern generator.
  *
@@ -18,10 +22,10 @@ export interface _ILengthProps {
  * length `fixed + segment.length` lands inside the requested window.
  *
  * `fixed` is the number of characters the format always contributes around the
- * segment, `fallback` is the segment length used when the leaf is
- * unconstrained on that side, and `minimum` is the smallest segment the format
- * still validates with. Throws when the window cannot be satisfied by this
- * format's shape (e.g. `Format<"email"> & MaxLength<3>`).
+ * segment, `fallback` is the segment length used when the leaf is unconstrained
+ * on that side, and `minimum` is the smallest segment the format still
+ * validates with. Throws when the window cannot be satisfied by this format's
+ * shape (e.g. `Format<"email"> & MaxLength<3>`).
  */
 export const _randomSegmentLength = (
   props: _ILengthProps | undefined,
@@ -36,21 +40,63 @@ export const _randomSegmentLength = (
   // characters so the generated length varies, mirroring `_randomString`.
   const high: number =
     props?.maxLength === undefined ? low + fallback : props.maxLength - fixed;
-  if (high < low || high < minimum)
-    throw new Error(
-      "unable to generate a random string satisfying both the format and the length constraints.",
-    );
+  if (high < low || high < minimum) throw new Error(_RANDOM_LENGTH_ERROR);
   return _randomString({ type: "string", minLength: low, maxLength: high });
 };
 
 /**
- * Wraps a fixed- or narrow-length format generator (uuid, ipv4, date, ...) with
- * the requested length window.
+ * Intersects the requested length window with the lengths a format's grammar
+ * can express, and draws one of them.
+ *
+ * `minimum` and `maximum` are the shortest and longest values the format admits
+ * — omit `maximum` when the grammar is open above — and `spread` is how far
+ * past the floor an unbounded request may reach, so an open side still varies
+ * the way `_randomString` does. The caller draws from the returned window and
+ * applies whatever step its grammar has (base64 lengths are multiples of four,
+ * a fractional second needs at least one digit).
+ *
+ * Throws only when the window and the grammar do not overlap at all. That is
+ * the distinction the retry driver below cannot make: it redraws one shape, so
+ * it gives up on every length that shape never emits even when the format
+ * itself accepts one (issue #2284).
+ */
+export const _randomLengthWindow = (
+  props: _ILengthProps | undefined,
+  format: { minimum: number; maximum?: number; spread?: number },
+): { low: number; high: number } => {
+  const ceiling: number = format.maximum ?? Number.MAX_SAFE_INTEGER;
+  const low: number = Math.max(
+    props?.minLength ?? format.minimum,
+    format.minimum,
+  );
+  const high: number = Math.min(
+    props?.maxLength ?? low + (format.spread ?? 0),
+    ceiling,
+  );
+  if (low > high) throw new Error(_RANDOM_LENGTH_ERROR);
+  return { low, high };
+};
+
+/** Draws a length inside a window produced by {@link _randomLengthWindow}. */
+export const _randomLengthPick = (window: {
+  low: number;
+  high: number;
+}): number =>
+  _randomInteger({
+    type: "integer",
+    minimum: window.low,
+    maximum: window.high,
+  });
+
+/**
+ * Wraps a fixed-length format generator (uuid, date) with the requested length
+ * window.
  *
- * These formats cannot grow an arbitrary segment, so the generator is retried a
- * bounded number of times and the first draw inside the window is returned. A
- * window that excludes every length the format can produce is unsatisfiable and
- * throws instead of silently yielding an out-of-range value.
+ * Use it only where the grammar admits exactly one length, so a window that
+ * excludes it is genuinely unsatisfiable. A format that can express more than
+ * one length must build its value at a length drawn from
+ * {@link _randomLengthWindow} instead; redrawing one shape cannot reach a length
+ * that shape never emits.
  */
 export const _randomFormatLength = (
   props: _ILengthProps | undefined,
@@ -66,7 +112,5 @@ export const _randomFormatLength = (
     )
       return value;
   }
-  throw new Error(
-    "unable to generate a random string satisfying both the format and the length constraints.",
-  );
+  throw new Error(_RANDOM_LENGTH_ERROR);
 };

package/src/internal/private/__notationRename.ts

@@ -9,10 +9,7 @@
  * collapsing it to the underscore-free `plain` path.
  */
 export const __notationRename =
-  (props: {
-    plain: (str: string) => string;
-    snake: (str: string) => string;
-  }) =>
+  (props: { plain: (str: string) => string; snake: (str: string) => string }) =>
   (str: string): string => {
     let prefix: string = "";
     while (str.startsWith("_")) {

package/src/internal/private/__randomComposition.ts

@@ -0,0 +1,50 @@
+import { _randomInteger } from "../_randomInteger";
+
+/**
+ * Splits `total` into `count` parts, each inside `[minimum, maximum]`.
+ *
+ * Used where a format's length is the sum of its segments — an IPv4 octet spans
+ * one to three digits, an IPv6 group one to four — so a requested total length
+ * is realized by choosing how many characters each segment contributes instead
+ * of redrawing whole addresses and hoping one lands in the window (issue
+ * #2284).
+ *
+ * The caller guarantees `count * minimum <= total <= count * maximum`; each
+ * part is drawn from the range that still leaves the remaining parts
+ * satisfiable.
+ */
+export const __randomComposition = (props: {
+  total: number;
+  count: number;
+  minimum: number;
+  maximum: number;
+}): number[] => {
+  const parts: number[] = [];
+  let remaining: number = props.total;
+  for (let i: number = 0; i < props.count; ++i) {
+    const rest: number = props.count - i - 1;
+    const value: number = _randomInteger({
+      type: "integer",
+      minimum: Math.max(props.minimum, remaining - rest * props.maximum),
+      maximum: Math.min(props.maximum, remaining - rest * props.minimum),
+    });
+    parts.push(value);
+    remaining -= value;
+  }
+  return parts;
+};
+
+/** Draws `length` decimal digits, leading zeros included. */
+export const __randomDigits = (length: number): string => {
+  let text: string = "";
+  for (let i: number = 0; i < length; ++i)
+    text += String(_randomInteger({ type: "integer", minimum: 0, maximum: 9 }));
+  return text;
+};
+
+/** Draws a decimal number of exactly `length` digits without a leading zero. */
+export const __randomNumeric = (length: number): string =>
+  length <= 1
+    ? String(_randomInteger({ type: "integer", minimum: 0, maximum: 9 }))
+    : String(_randomInteger({ type: "integer", minimum: 1, maximum: 9 })) +
+      __randomDigits(length - 1);

package/src/internal/private/__randomEpoch.ts

@@ -0,0 +1,34 @@
+import { _randomInteger } from "../_randomInteger";
+
+export interface __IEpochProps {
+  minimum?: number;
+  maximum?: number;
+}
+
+/**
+ * Draws an epoch millisecond inside the requested bounds.
+ *
+ * Shared by the `date` and `date-time` generators, which had the same bound
+ * expression written twice: `props?.maximum ?? props?.minimum === undefined`
+ * parses as `props?.maximum ?? (props?.minimum === undefined)` because `??`
+ * binds looser than `===`, so any supplied `maximum` made the condition truthy
+ * and was replaced by `Date.now()`, while `maximum: 0` fell through to
+ * `undefined + one year` and produced `NaN` (issue #2287). Keeping the
+ * resolution in one place is what stops the two copies from drifting again.
+ *
+ * With no bound at all the window ends at the present instant; with only a
+ * lower bound it spans one year from there.
+ */
+export const __randomEpoch = (props?: __IEpochProps): number => {
+  const minimum: number = props?.minimum ?? 0;
+  const maximum: number =
+    props?.maximum ??
+    (props?.minimum === undefined ? Date.now() : props.minimum + YEAR);
+  return _randomInteger({
+    type: "integer",
+    minimum,
+    maximum,
+  });
+};
+
+const YEAR = 365 * 24 * 60 * 60 * 1_000;

package/native/adapter/visit.go

@@ -1,173 +0,0 @@
-package adapter
-
-import (
-  "path/filepath"
-  "strings"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimchecker "github.com/microsoft/typescript-go/shim/checker"
-)
-
-type CallSite struct {
-  File       *shimast.SourceFile
-  FilePath   string
-  Module     string
-  Method     string
-  Call       *shimast.CallExpression
-  RootName   string
-  Namespaces []string
-}
-
-func CollectCallSites(files []*shimast.SourceFile, checker *shimchecker.Checker) []CallSite {
-  sites := []CallSite{}
-  for _, file := range files {
-    if file == nil || file.IsDeclarationFile {
-      continue
-    }
-    file.ForEachChild(func(node *shimast.Node) bool {
-      visitCallSite(file, checker, node, &sites)
-      return false
-    })
-  }
-  return sites
-}
-
-func visitCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node, sites *[]CallSite) {
-  if node == nil {
-    return
-  }
-  if node.Kind == shimast.KindCallExpression {
-    if site, ok := tryCallSite(file, checker, node); ok {
-      *sites = append(*sites, site)
-    }
-  }
-  node.ForEachChild(func(child *shimast.Node) bool {
-    visitCallSite(file, checker, child, sites)
-    return false
-  })
-}
-
-func tryCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node) (CallSite, bool) {
-  if checker == nil {
-    return CallSite{}, false
-  }
-  if node.Kind != shimast.KindCallExpression {
-    return CallSite{}, false
-  }
-  call := node.AsCallExpression()
-  if call == nil {
-    return CallSite{}, false
-  }
-  signature := checker.GetResolvedSignature(node)
-  if signature == nil {
-    return CallSite{}, false
-  }
-  declaration := signature.Declaration()
-  if declaration == nil {
-    return CallSite{}, false
-  }
-  sourceFile := shimast.GetSourceFileOfNode(declaration)
-  if sourceFile == nil {
-    return CallSite{}, false
-  }
-  module, ok := matchTypiaModule(sourceFile.FileName())
-  if !ok {
-    return CallSite{}, false
-  }
-  method := callSiteMethodName(checker, declaration, call)
-  if method == "" {
-    return CallSite{}, false
-  }
-  root, namespaces, ok := extractRootAndNamespaces(call, method)
-  if !ok {
-    return CallSite{}, false
-  }
-  return CallSite{
-    File:       file,
-    FilePath:   file.FileName(),
-    Module:     module,
-    Method:     method,
-    Call:       call,
-    RootName:   root,
-    Namespaces: namespaces,
-  }, true
-}
-
-func matchTypiaModule(location string) (string, bool) {
-  location = filepath.ToSlash(location)
-  for _, suffix := range []string{".d.ts", ".ts"} {
-    for _, middle := range []string{"typia/lib/", "typia/src/", "packages/typia/src/"} {
-      index := strings.LastIndex(location, middle)
-      if index < 0 {
-        continue
-      }
-      name := location[index+len(middle):]
-      if !strings.HasSuffix(name, suffix) {
-        continue
-      }
-      name = strings.TrimSuffix(name, suffix)
-      if strings.Contains(name, "/") {
-        continue
-      }
-      return name, true
-    }
-  }
-  return "", false
-}
-
-func callSiteMethodName(checker *shimchecker.Checker, declaration *shimast.Node, call *shimast.CallExpression) string {
-  if name := declaration.Name(); name != nil {
-    if checker != nil {
-      if symbol := checker.GetSymbolAtLocation(name); symbol != nil && symbol.Name != "" {
-        return symbol.Name
-      }
-    }
-    if name.Kind == shimast.KindIdentifier {
-      if id := name.AsIdentifier(); id != nil {
-        return id.Text
-      }
-    }
-  }
-  if call.Expression != nil && call.Expression.Kind == shimast.KindPropertyAccessExpression {
-    if property := call.Expression.AsPropertyAccessExpression(); property != nil {
-      if name := property.Name(); name != nil && name.Kind == shimast.KindIdentifier {
-        if id := name.AsIdentifier(); id != nil {
-          return id.Text
-        }
-      }
-    }
-  }
-  return ""
-}
-
-func extractRootAndNamespaces(call *shimast.CallExpression, method string) (string, []string, bool) {
-  expression := call.Expression
-  segments := []string{}
-  for expression != nil && expression.Kind == shimast.KindPropertyAccessExpression {
-    property := expression.AsPropertyAccessExpression()
-    if property == nil {
-      break
-    }
-    name := property.Name()
-    if name == nil || name.Kind != shimast.KindIdentifier {
-      return "", nil, false
-    }
-    id := name.AsIdentifier()
-    if id == nil || id.Text == "" {
-      return "", nil, false
-    }
-    segments = append([]string{id.Text}, segments...)
-    expression = property.Expression
-  }
-  if expression == nil || expression.Kind != shimast.KindIdentifier {
-    return "", nil, false
-  }
-  root := expression.AsIdentifier()
-  if root == nil || root.Text == "" || len(segments) == 0 {
-    return "", nil, false
-  }
-  if segments[len(segments)-1] != method {
-    return "", nil, false
-  }
-  return root.Text, segments[:len(segments)-1], true
-}

package/native/adapter/visit_property_chain_edges_test.go

@@ -1,129 +0,0 @@
-//go:build typia_native_internal
-// +build typia_native_internal
-
-package adapter
-
-import (
-	"path/filepath"
-	"testing"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	shimcore "github.com/microsoft/typescript-go/shim/core"
-	shimparser "github.com/microsoft/typescript-go/shim/parser"
-)
-
-// TestVisitPropertyChainEdges verifies call-site property-chain parsing.
-//
-// Call-site discovery peels a TypeScript expression like
-// `typia.json.stringify()` into a root import name, namespace chain, and method.
-// Malformed or mismatched chains must be rejected without producing a site.
-//
-// 1. Build a nested property-access call expression.
-// 2. Extract the root name, namespace, and terminal method.
-// 3. Reject a method mismatch, a non-property call, and an empty member name.
-// 4. Verify nil nodes do not append call sites.
-func TestVisitPropertyChainEdges(t *testing.T) {
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	namespace := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewIdentifier("json"),
-		shimast.NodeFlagsNone,
-	)
-	method := factory.NewPropertyAccessExpression(
-		namespace,
-		nil,
-		factory.NewIdentifier("stringify"),
-		shimast.NodeFlagsNone,
-	)
-	call := factory.NewCallExpression(method, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-
-	root, namespaces, ok := extractRootAndNamespaces(call, "stringify")
-	if !ok || root != "typia" || len(namespaces) != 1 || namespaces[0] != "json" {
-		t.Fatalf("unexpected property-chain extraction: root=%q namespaces=%#v ok=%v", root, namespaces, ok)
-	}
-	if _, _, ok := extractRootAndNamespaces(call, "is"); ok {
-		t.Fatal("method mismatch should reject the call chain")
-	}
-	statement := factory.NewExpressionStatement(factory.NewIdentifier("noop"))
-	if method := callSiteMethodName(nil, statement, call); method != "stringify" {
-		t.Fatalf("property-access method fallback mismatch: %q", method)
-	}
-	declaration := factory.NewFunctionDeclaration(
-		nil,
-		nil,
-		factory.NewIdentifier("declared"),
-		nil,
-		nil,
-		nil,
-		nil,
-		nil,
-	)
-	if method := callSiteMethodName(nil, declaration, call); method != "declared" {
-		t.Fatalf("declaration-name fallback mismatch: %q", method)
-	}
-
-	plain := factory.NewCallExpression(
-		factory.NewIdentifier("plain"),
-		nil,
-		nil,
-		factory.NewNodeList(nil),
-		shimast.NodeFlagsNone,
-	).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(plain, "plain"); ok {
-		t.Fatal("plain calls without a property chain should be rejected")
-	}
-	literal := factory.NewCallExpression(
-		factory.NewStringLiteral("call", shimast.TokenFlagsNone),
-		nil,
-		nil,
-		factory.NewNodeList(nil),
-		shimast.NodeFlagsNone,
-	).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(literal, "call"); ok {
-		t.Fatal("non-identifier root expressions should be rejected")
-	}
-
-	emptyMember := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewIdentifier(""),
-		shimast.NodeFlagsNone,
-	)
-	emptyCall := factory.NewCallExpression(emptyMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(emptyCall, ""); ok {
-		t.Fatal("empty property name should be rejected")
-	}
-	stringMember := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewStringLiteral("is", shimast.TokenFlagsNone),
-		shimast.NodeFlagsNone,
-	)
-	stringMemberCall := factory.NewCallExpression(stringMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(stringMemberCall, "is"); ok {
-		t.Fatal("non-identifier property names should be rejected")
-	}
-	sites := []CallSite{}
-	visitCallSite(nil, nil, nil, &sites)
-	if len(sites) != 0 {
-		t.Fatalf("nil node should not append call sites: %#v", sites)
-	}
-	file := shimparser.ParseSourceFile(
-		shimast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "visit.ts"))},
-		`typia.is(input);`,
-		shimcore.ScriptKindTS,
-	)
-	declFile := *file
-	declFile.IsDeclarationFile = true
-	if sites := CollectCallSites([]*shimast.SourceFile{nil, &declFile}, nil); len(sites) != 0 {
-		t.Fatalf("nil and declaration files should not produce call sites: %#v", sites)
-	}
-	if _, ok := tryCallSite(file, nil, call.AsNode()); ok {
-		t.Fatal("nil checker should reject call-site probing")
-	}
-	if _, ok := tryCallSite(file, &shimchecker.Checker{}, statement); ok {
-		t.Fatal("non-call nodes should reject call-site probing")
-	}
-}

package/native/core/programmers/helpers/disable_function_programmer_declare.go

@@ -1,10 +0,0 @@
-package helpers
-
-func Disable_function_programmer_declare(functor *FunctionProgrammer) *FunctionProgrammer {
-  if functor == nil {
-    return nil
-  }
-  disabled := *functor
-  disabled.disableDeclare = true
-  return &disabled
-}