typia 13.2.0 → 13.3.0

package/src/internal/_randomFormatTime.ts

@@ -15,12 +15,11 @@ export const _randomFormatTime = (props?: _ILengthProps): string => {
   if (props?.minLength === undefined && props?.maxLength === undefined)
     return clock().substring(11);
   // `HH:MM:SS` carries a mandatory offset — one character as `Z`, six as
-  // `+HH:MM` — and an optional fraction of one to nine digits between them.
-  // Together they express 9 and every length from 11 through 24; 10 is the one
-  // gap, because a fraction needs both a dot and a digit.
+  // `+HH:MM` — and an optional fraction between them that RFC 3339 leaves
+  // open above. Together they express 9 and every length from 11 upward; 10 is
+  // the one gap, because a fraction needs both a dot and a digit.
   const window = _randomLengthWindow(props, {
     minimum: CLOCK + 1,
-    maximum: CLOCK + 1 + FRACTION_MAX + OFFSET,
     spread: 6,
   });
   let length: number = _randomLengthPick(window);
@@ -30,17 +29,23 @@ export const _randomFormatTime = (props?: _ILengthProps): string => {
     throw new Error(_RANDOM_LENGTH_ERROR);
   const base: string = clock().substring(11, 11 + CLOCK);
   if (length === CLOCK + 1) return `${base}Z`;
-  // Nine fraction digits cap the `Z` form at 19 characters, so anything longer
-  // spends the extra five on a numeric offset instead.
-  return length <= CLOCK + 2 + FRACTION_MAX
-    ? `${base}.${__randomDigits(length - CLOCK - 2)}Z`
-    : `${base}.${__randomDigits(length - CLOCK - 1 - OFFSET)}${offset()}`;
+  // The `Z` form reaches every remaining length by itself, so the numeric
+  // offset is a choice rather than a fallback: it spends six characters, which
+  // leaves either nothing (14, `HH:MM:SS+HH:MM`) or a whole fraction (16 and
+  // up). At 15 only the `Z` form fits, since the offset would demand a dot
+  // with no digit after it.
+  const fraction: number = length - CLOCK - OFFSET - 1;
+  return (fraction === -1 || fraction >= 1) &&
+    _randomInteger({ type: "integer", minimum: 0, maximum: 1 }) === 1
+    ? fraction === -1
+      ? `${base}${offset()}`
+      : `${base}.${__randomDigits(fraction)}${offset()}`
+    : `${base}.${__randomDigits(length - CLOCK - 2)}Z`;
 };
 
 const DAY = 86_400_000;
 const CLOCK = "00:00:00".length;
 const OFFSET = "+00:00".length;
-const FRACTION_MAX = 9;
 
 const offset = (): string =>
   `${_randomInteger({ type: "integer", minimum: 0, maximum: 1 }) === 0 ? "+" : "-"}${pad(

package/src/internal/private/__randomComposition.ts

@@ -34,6 +34,30 @@ export const __randomComposition = (props: {
   return parts;
 };
 
+/**
+ * Draws `length` characters of the base64 alphabet.
+ *
+ * The caller passes a multiple of four, which `format: "byte"` accepts without
+ * padding; every character below is in the alphabet its validator spells out,
+ * so the result needs no encoding step.
+ */
+export const __randomBase64 = (length: number): string => {
+  let text: string = "";
+  for (let i: number = 0; i < length; ++i)
+    text +=
+      BASE64[
+        _randomInteger({
+          type: "integer",
+          minimum: 0,
+          maximum: BASE64.length - 1,
+        })
+      ];
+  return text;
+};
+
+const BASE64 =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
 /** Draws `length` decimal digits, leading zeros included. */
 export const __randomDigits = (length: number): string => {
   let text: string = "";

package/src/json.ts

@@ -431,10 +431,16 @@ export function createAssertParse(
  */
 export function createAssertParse<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: string) => Primitive<T>;
+): (
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Primitive<T>;
 
 /** @internal */
-export function createAssertParse<T>(): (input: string) => Primitive<T> {
+export function createAssertParse<T>(): (
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Primitive<T> {
   NoTransformConfigurationError("json.createAssertParse");
 }
 
@@ -501,10 +507,16 @@ export function createAssertStringify(
  */
 export function createAssertStringify<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => string;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => string;
 
 /** @internal */
-export function createAssertStringify(): (input: unknown) => string {
+export function createAssertStringify(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => string {
   NoTransformConfigurationError("json.createAssertStringify");
 }
 

package/src/module.ts

@@ -1,10 +1,5 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import {
-  AssertionGuard,
-  IRandomGenerator,
-  IValidation,
-  Resolved,
-} from "@typia/interface";
+import { IRandomGenerator, IValidation, Resolved } from "@typia/interface";
 
 import { TypeGuardError } from "./TypeGuardError";
 import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
@@ -577,7 +572,7 @@ export function random(): never {
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assert function `(input: unknown) => T`
+ * @returns Reusable assert function `(input: unknown, errorFactory?) => T`
  * @danger You must configure the generic argument `T`
  */
 export function createAssert(
@@ -593,14 +588,21 @@ export function createAssert(
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assert function `(input: unknown) => T`
+ * @returns Reusable assert function `(input: unknown, errorFactory?) => T`,
+ *   whose own `errorFactory` overrides this one for that single call
  */
 export function createAssert<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
-export function createAssert<T>(): (input: unknown) => T {
+export function createAssert<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T {
   NoTransformConfigurationError("createAssert");
 }
 
@@ -611,6 +613,9 @@ export function createAssert<T>(): (input: unknown) => T {
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.
+ * That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
@@ -629,18 +634,28 @@ export function createAssertGuard(
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.
+ * That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertion guard function
+ * @returns Reusable assertion guard function, whose own `errorFactory`
+ *   overrides this one for that single call
  */
 export function createAssertGuard<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): AssertionGuard<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T;
 
 /** @internal */
-export function createAssertGuard<T>(): AssertionGuard<T> {
+export function createAssertGuard<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T {
   NoTransformConfigurationError("createAssertGuard");
 }
 
@@ -747,7 +762,8 @@ export function createValidate(): ((input: unknown) => IValidation) &
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertEquals function `(input: unknown) => T`
+ * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>
+ *   T`
  * @danger You must configure the generic argument `T`
  */
 export function createAssertEquals(
@@ -763,14 +779,21 @@ export function createAssertEquals(
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertEquals function `(input: unknown) => T`
+ * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>
+ *   T`, whose own `errorFactory` overrides this one for that single call
  */
 export function createAssertEquals<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
-export function createAssertEquals<T>(): (input: unknown) => T {
+export function createAssertEquals<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T {
   NoTransformConfigurationError("createAssertEquals");
 }
 
@@ -781,7 +804,9 @@ export function createAssertEquals<T>(): (input: unknown) => T {
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile
- * error.
+ * error. That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
@@ -800,19 +825,28 @@ export function createAssertGuardEquals(
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile
- * error.
+ * error. That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertion guard function
+ * @returns Reusable assertion guard function, whose own `errorFactory`
+ *   overrides this one for that single call
  */
 export function createAssertGuardEquals<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): AssertionGuard<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T;
 
 /** @internal */
-export function createAssertGuardEquals<T>(): AssertionGuard<T> {
+export function createAssertGuardEquals<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T {
   NoTransformConfigurationError("createAssertGuardEquals");
 }
 

package/src/notations.ts

@@ -530,7 +530,10 @@ export function createAssertCamel(
  */
 export function createAssertCamel<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => CamelCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => CamelCase<T>;
 
 /** @internal */
 export function createAssertCamel(): never {
@@ -618,7 +621,10 @@ export function createAssertPascal(
  */
 export function createAssertPascal<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => PascalCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => PascalCase<T>;
 
 /** @internal */
 export function createAssertPascal(): never {
@@ -706,7 +712,10 @@ export function createAssertSnake(
  */
 export function createAssertSnake<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => SnakeCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => SnakeCase<T>;
 
 /** @internal */
 export function createAssertSnake(): never {
@@ -794,7 +803,10 @@ export function createAssertKebab(
  */
 export function createAssertKebab<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => KebabCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => KebabCase<T>;
 
 /** @internal */
 export function createAssertKebab(): never {

package/src/plain.ts

@@ -383,7 +383,10 @@ export function createAssertClone(
  */
 export function createAssertClone<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => Resolved<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T>;
 
 /** @internal */
 export function createAssertClone(): never {
@@ -471,7 +474,10 @@ export function createAssertPrune(
  */
 export function createAssertPrune<T extends object>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
 export function createAssertPrune(): never {
@@ -563,7 +569,10 @@ export function createAssertClassify(
  */
 export function createAssertClassify<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => ClassifyResult<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => ClassifyResult<T>;
 
 /** @internal */
 export function createAssertClassify(): never {

package/src/protobuf.ts

@@ -377,10 +377,16 @@ export function createAssertDecode(
  */
 export function createAssertDecode<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: Uint8Array) => Resolved<T>;
+): (
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T>;
 
 /** @internal */
-export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
+export function createAssertDecode<T>(): (
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T> {
   NoTransformConfigurationError("protobuf.createAssertDecode");
 }
 
@@ -467,10 +473,16 @@ export function createAssertEncode(
  */
 export function createAssertEncode<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => Uint8Array;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Uint8Array;
 
 /** @internal */
-export function createAssertEncode<T>(): (input: T) => Uint8Array {
+export function createAssertEncode<T>(): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Uint8Array {
   NoTransformConfigurationError("protobuf.createAssertEncode");
 }