typia 13.1.0 → 13.1.19

package/src/internal/_randomFormatTime.ts

@@ -1,14 +1,17 @@
 import { _randomInteger } from "./_randomInteger";
+import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
 
-export const _randomFormatTime = (): string =>
-  new Date(
-    _randomInteger({
-      type: "integer",
-      minimum: 0,
-      maximum: DAY,
-    }),
-  )
-    .toISOString()
-    .substring(11);
+export const _randomFormatTime = (props?: _ILengthProps): string =>
+  _randomFormatLength(props, () =>
+    new Date(
+      _randomInteger({
+        type: "integer",
+        minimum: 0,
+        maximum: DAY,
+      }),
+    )
+      .toISOString()
+      .substring(11),
+  );
 
 const DAY = 86_400_000;

package/src/internal/_randomFormatUri.ts

@@ -1,3 +1,5 @@
 import { _randomFormatUrl } from "./_randomFormatUrl";
+import { _ILengthProps } from "./_randomStringLength";
 
-export const _randomFormatUri = (): string => _randomFormatUrl();
+export const _randomFormatUri = (props?: _ILengthProps): string =>
+  _randomFormatUrl(props);

package/src/internal/_randomFormatUriReference.ts

@@ -1,3 +1,5 @@
 import { _randomFormatUrl } from "./_randomFormatUrl";
+import { _ILengthProps } from "./_randomStringLength";
 
-export const _randomFormatUriReference = (): string => _randomFormatUrl();
+export const _randomFormatUriReference = (props?: _ILengthProps): string =>
+  _randomFormatUrl(props);

package/src/internal/_randomFormatUriTemplate.ts

@@ -1,3 +1,5 @@
 import { _randomFormatUrl } from "./_randomFormatUrl";
+import { _ILengthProps } from "./_randomStringLength";
 
-export const _randomFormatUriTemplate = (): string => _randomFormatUrl();
+export const _randomFormatUriTemplate = (props?: _ILengthProps): string =>
+  _randomFormatUrl(props);

package/src/internal/_randomFormatUrl.ts

@@ -1,7 +1,30 @@
+import { _randomInteger } from "./_randomInteger";
 import { _randomString } from "./_randomString";
+import { _ILengthProps } from "./_randomStringLength";
 
-export const _randomFormatUrl = (): string =>
-  `https://${random(10)}.${random(3)}`;
+export const _randomFormatUrl = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return `https://${random(10)}.${random(3)}`;
+  // `https://a.bc` is the shortest host this builder emits (12 chars); any extra
+  // length rides in the path segment, which the URL grammar leaves unbounded.
+  const base: string = `https://${random(1)}.${random(2)}`;
+  const target: number = pickLength(props, base.length);
+  return target <= base.length
+    ? base
+    : `${base}/${random(target - base.length - 1)}`;
+};
+
+const pickLength = (props: _ILengthProps, base: number): number => {
+  let low: number = props.minLength === undefined ? base : props.minLength;
+  if (low < base) low = base;
+  const high: number =
+    props.maxLength === undefined ? low + 14 : props.maxLength;
+  if (high < low)
+    throw new Error(
+      "unable to generate a random URL satisfying both the format and the length constraints.",
+    );
+  return _randomInteger({ type: "integer", minimum: low, maximum: high });
+};
 
 const random = (length: number) =>
   _randomString({

package/src/internal/_randomFormatUuid.ts

@@ -1,6 +1,10 @@
-export const _randomFormatUuid = (): string =>
-  "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === "x" ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
+import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+
+export const _randomFormatUuid = (props?: _ILengthProps): string =>
+  _randomFormatLength(props, () =>
+    "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = (Math.random() * 16) | 0;
+      const v = c === "x" ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    }),
+  );

package/src/internal/_randomInteger.ts

@@ -1,53 +1,100 @@
 import { OpenApi } from "@typia/interface";
 
-export const _randomInteger = (schema: OpenApi.IJsonSchema.IInteger) => {
-  let minimum: number =
-    schema.minimum ??
-    schema.exclusiveMinimum ??
-    (schema.multipleOf ?? 1) *
-      (schema.maximum === undefined && schema.exclusiveMaximum === undefined
-        ? 0
-        : (schema.maximum ?? schema.exclusiveMaximum!) - 100);
-  if (schema.exclusiveMinimum !== undefined) minimum++;
-  let maximum: number =
-    schema.maximum ??
-    schema.exclusiveMaximum ??
-    (schema.multipleOf ?? 1) *
-      (schema.minimum === undefined && schema.exclusiveMinimum === undefined
-        ? 100
-        : (schema.minimum ?? schema.exclusiveMinimum!) + 100);
-  if (schema.exclusiveMaximum !== undefined) maximum--;
+import { _randomMultiple } from "./_randomMultiple";
+
+export const _randomInteger = (
+  schema: OpenApi.IJsonSchema.IInteger,
+): number => {
+  const lower: IBoundary | null = getLowerBoundary(schema);
+  const upper: IBoundary | null = getUpperBoundary(schema);
+  const minimum: number =
+    lower?.value ?? (upper === null ? 0 : upper.value - 100);
+  const maximum: number =
+    upper?.value ?? (lower === null ? 100 : lower.value + 100);
   if (minimum > maximum)
     throw new Error("Minimum value is greater than maximum value.");
   return schema.multipleOf === undefined
-    ? scalar({
-        minimum,
-        maximum,
-      })
-    : multiple({
+    ? scalar({ minimum, maximum })
+    : _randomMultiple({
         minimum,
         maximum,
         multipleOf: schema.multipleOf,
+        exclusiveMinimum: lower?.exclusive ?? false,
+        exclusiveMaximum: upper?.exclusive ?? false,
+        integer: true,
       });
 };
 
-const scalar = (p: { minimum: number; maximum: number }): number =>
-  Math.floor(Math.random() * (p.maximum - p.minimum + 1)) + p.minimum;
+const scalar = (props: { minimum: number; maximum: number }): number => {
+  const minimum: number = Math.ceil(props.minimum);
+  const maximum: number = Math.floor(props.maximum);
+  if (minimum > maximum) throw new Error("The integer range is empty.");
+  return Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
+};
 
-const multiple = (p: {
-  minimum: number;
-  maximum: number;
-  multipleOf: number;
-}): number => {
-  const minimum = Math.ceil(p.minimum / p.multipleOf) * p.multipleOf;
-  const maximum = Math.floor(p.maximum / p.multipleOf) * p.multipleOf;
-  if (minimum > maximum)
-    throw new Error(
-      "The range of the integer is smaller than the multipleOf value.",
-    );
-  const value: number = scalar({
-    minimum,
-    maximum,
-  });
-  return value - (value % p.multipleOf);
+const getLowerBoundary = (
+  schema: OpenApi.IJsonSchema.IInteger,
+): IBoundary | null => {
+  const inclusive: IBoundary | null =
+    schema.minimum === undefined
+      ? null
+      : { value: schema.minimum, exclusive: false };
+  const exclusive: IBoundary | null =
+    schema.exclusiveMinimum === undefined
+      ? null
+      : { value: schema.exclusiveMinimum, exclusive: true };
+  const selected: IBoundary | null = selectBoundary(
+    inclusive,
+    exclusive,
+    Math.max,
+  );
+  if (selected === null) return null;
+  return {
+    value: selected.exclusive
+      ? Math.floor(selected.value) + 1
+      : Math.ceil(selected.value),
+    exclusive: false,
+  };
 };
+
+const getUpperBoundary = (
+  schema: OpenApi.IJsonSchema.IInteger,
+): IBoundary | null => {
+  const inclusive: IBoundary | null =
+    schema.maximum === undefined
+      ? null
+      : { value: schema.maximum, exclusive: false };
+  const exclusive: IBoundary | null =
+    schema.exclusiveMaximum === undefined
+      ? null
+      : { value: schema.exclusiveMaximum, exclusive: true };
+  const selected: IBoundary | null = selectBoundary(
+    inclusive,
+    exclusive,
+    Math.min,
+  );
+  if (selected === null) return null;
+  return {
+    value: selected.exclusive
+      ? Math.ceil(selected.value) - 1
+      : Math.floor(selected.value),
+    exclusive: false,
+  };
+};
+
+const selectBoundary = (
+  x: IBoundary | null,
+  y: IBoundary | null,
+  compare: (x: number, y: number) => number,
+): IBoundary | null => {
+  if (x === null) return y;
+  if (y === null) return x;
+  if (x.value === y.value)
+    return { value: x.value, exclusive: x.exclusive || y.exclusive };
+  return compare(x.value, y.value) === x.value ? x : y;
+};
+
+interface IBoundary {
+  value: number;
+  exclusive: boolean;
+}

package/src/internal/_randomMultiple.ts

@@ -0,0 +1,245 @@
+import {
+  _IDecimal,
+  _IDecimalRatio,
+  _decimalDecompose,
+  _decimalDivide,
+  _decimalGcd,
+  _decimalIntegerStep,
+  _decimalPower,
+  _decimalToNumber,
+} from "./_decimal";
+import { _isMultipleOf } from "./_isMultipleOf";
+
+export const _randomMultiple = (props: {
+  minimum: number;
+  maximum: number;
+  multipleOf: number;
+  exclusiveMinimum: boolean;
+  exclusiveMaximum: boolean;
+  integer: boolean;
+}): number => {
+  const step: _IDecimal | null = props.integer
+    ? _decimalIntegerStep(props.multipleOf)
+    : _decimalDecompose(props.multipleOf);
+  if (step === null || step.coefficient <= BigInt(0))
+    throw new Error("The multipleOf value must be a positive finite number.");
+
+  const lower: _IDecimalRatio | null = _decimalDivide(props.minimum, step);
+  const upper: _IDecimalRatio | null = _decimalDivide(props.maximum, step);
+  if (lower === null || upper === null)
+    throw new Error("The random number range must be finite.");
+  const minimum: bigint = lowerBound(lower, props.exclusiveMinimum);
+  const maximum: bigint = upperBound(upper, props.exclusiveMaximum);
+  if (minimum > maximum)
+    throw new Error("The range does not contain a multipleOf value.");
+
+  const selected: bigint = randomBigint(minimum, maximum);
+  const candidates: bigint[] = unique([
+    selected,
+    minimum,
+    maximum,
+    clamp(BigInt(0), minimum, maximum),
+    clamp(BigInt(1), minimum, maximum),
+    clamp(BigInt(-1), minimum, maximum),
+    ...nearby(selected, minimum, maximum),
+  ]);
+  for (const coefficient of candidates) {
+    const value: number = _decimalToNumber({
+      coefficient: step.coefficient * coefficient,
+      exponent: step.exponent,
+    });
+    if (isValid(props, value)) return value;
+  }
+  const aligned: number | null = findRepresentableIntegerMultiple(props);
+  if (aligned !== null) return aligned;
+  const decimalAligned: number | null = findRepresentableDecimalMultiple(
+    props,
+    step,
+  );
+  if (decimalAligned !== null) return decimalAligned;
+  throw new Error(
+    "The range does not contain a representable multipleOf value.",
+  );
+};
+
+const isValid = (
+  props: Parameters<typeof _randomMultiple>[0],
+  value: number,
+): boolean =>
+  Number.isFinite(value) &&
+  (props.integer === false || Number.isInteger(value)) &&
+  (props.exclusiveMinimum ? value > props.minimum : value >= props.minimum) &&
+  (props.exclusiveMaximum ? value < props.maximum : value <= props.maximum) &&
+  _isMultipleOf(value, props.multipleOf);
+
+const findRepresentableDecimalMultiple = (
+  props: Parameters<typeof _randomMultiple>[0],
+  step: _IDecimal,
+): number | null => {
+  const limit: bigint = BigInt("999999999999999");
+  for (let exponent = -324; exponent <= 308; ++exponent) {
+    const unit: _IDecimal = { coefficient: BigInt(1), exponent };
+    const lower: _IDecimalRatio | null = _decimalDivide(props.minimum, unit);
+    const upper: _IDecimalRatio | null = _decimalDivide(props.maximum, unit);
+    if (lower === null || upper === null) return null;
+
+    const coefficientMinimum: bigint = max(
+      -limit,
+      lowerBound(lower, props.exclusiveMinimum),
+    );
+    const coefficientMaximum: bigint = min(
+      limit,
+      upperBound(upper, props.exclusiveMaximum),
+    );
+    if (coefficientMinimum > coefficientMaximum) continue;
+
+    const coefficientStep: bigint = decimalCoefficientStep(step, exponent);
+    const minimum: bigint = lowerBound(
+      { numerator: coefficientMinimum, denominator: coefficientStep },
+      false,
+    );
+    const maximum: bigint = upperBound(
+      { numerator: coefficientMaximum, denominator: coefficientStep },
+      false,
+    );
+    if (minimum > maximum) continue;
+
+    const selected: bigint = randomBigint(minimum, maximum);
+    for (const quotient of unique([
+      selected,
+      minimum,
+      maximum,
+      clamp(BigInt(0), minimum, maximum),
+      ...nearby(selected, minimum, maximum),
+    ])) {
+      const value: number = _decimalToNumber({
+        coefficient: coefficientStep * quotient,
+        exponent,
+      });
+      if (isValid(props, value)) return value;
+    }
+  }
+  return null;
+};
+
+const decimalCoefficientStep = (step: _IDecimal, exponent: number): bigint => {
+  const difference: number = exponent - step.exponent;
+  if (difference >= 0) {
+    const power: bigint = _decimalPower(difference);
+    return step.coefficient / _decimalGcd(step.coefficient, power);
+  }
+  return step.coefficient * _decimalPower(-difference);
+};
+
+const findRepresentableIntegerMultiple = (
+  props: Parameters<typeof _randomMultiple>[0],
+): number | null => {
+  const step: _IDecimal | null = _decimalIntegerStep(props.multipleOf);
+  if (step === null) return null;
+  const unit: _IDecimal = { coefficient: BigInt(1), exponent: 0 };
+  const lower: _IDecimalRatio | null = _decimalDivide(props.minimum, unit);
+  const upper: _IDecimalRatio | null = _decimalDivide(props.maximum, unit);
+  if (lower === null || upper === null) return null;
+
+  const minimum: bigint = lowerBound(lower, props.exclusiveMinimum);
+  const maximum: bigint = upperBound(upper, props.exclusiveMaximum);
+  if (minimum > maximum) return null;
+  if (minimum <= BigInt(0) && maximum >= BigInt(0)) return 0;
+
+  const candidate: bigint | null =
+    minimum > BigInt(0)
+      ? findPositiveAligned(minimum, maximum, step.coefficient)
+      : (() => {
+          const magnitude: bigint | null = findPositiveAligned(
+            -maximum,
+            -minimum,
+            step.coefficient,
+          );
+          return magnitude === null ? null : -magnitude;
+        })();
+  if (candidate === null) return null;
+  const value: number = Number(candidate);
+  return isValid(props, value) ? value : null;
+};
+
+const findPositiveAligned = (
+  minimum: bigint,
+  maximum: bigint,
+  integerStep: bigint,
+): bigint | null => {
+  const first: number = bitLength(minimum) - 1;
+  const last: number = bitLength(maximum) - 1;
+  for (let exponent = first; exponent <= last; ++exponent) {
+    const bandMinimum: bigint = max(minimum, BigInt(1) << BigInt(exponent));
+    const bandMaximum: bigint = min(
+      maximum,
+      (BigInt(1) << BigInt(exponent + 1)) - BigInt(1),
+    );
+    const quantum: bigint =
+      exponent <= 52 ? BigInt(1) : BigInt(1) << BigInt(exponent - 52);
+    const alignedStep: bigint =
+      (integerStep / _decimalGcd(integerStep, quantum)) * quantum;
+    const lower: bigint = lowerBound(
+      { numerator: bandMinimum, denominator: alignedStep },
+      false,
+    );
+    const upper: bigint = upperBound(
+      { numerator: bandMaximum, denominator: alignedStep },
+      false,
+    );
+    if (lower <= upper) return randomBigint(lower, upper) * alignedStep;
+  }
+  return null;
+};
+
+const bitLength = (value: bigint): number => value.toString(2).length;
+
+const min = (x: bigint, y: bigint): bigint => (x < y ? x : y);
+const max = (x: bigint, y: bigint): bigint => (x > y ? x : y);
+
+const lowerBound = (ratio: _IDecimalRatio, exclusive: boolean): bigint => {
+  const quotient: bigint = ratio.numerator / ratio.denominator;
+  const remainder: bigint = ratio.numerator % ratio.denominator;
+  const ceiling: bigint =
+    quotient + (remainder > BigInt(0) ? BigInt(1) : BigInt(0));
+  return (
+    ceiling + (exclusive && remainder === BigInt(0) ? BigInt(1) : BigInt(0))
+  );
+};
+
+const upperBound = (ratio: _IDecimalRatio, exclusive: boolean): bigint => {
+  const quotient: bigint = ratio.numerator / ratio.denominator;
+  const remainder: bigint = ratio.numerator % ratio.denominator;
+  const floor: bigint =
+    quotient - (remainder < BigInt(0) ? BigInt(1) : BigInt(0));
+  return floor - (exclusive && remainder === BigInt(0) ? BigInt(1) : BigInt(0));
+};
+
+const randomBigint = (minimum: bigint, maximum: bigint): bigint => {
+  const scale: bigint = BigInt(1) << BigInt(53);
+  const sample: bigint = BigInt(
+    Math.min(
+      Number(scale - BigInt(1)),
+      Math.floor(Math.max(0, Math.random()) * Number(scale)),
+    ),
+  );
+  return minimum + ((maximum - minimum + BigInt(1)) * sample) / scale;
+};
+
+const clamp = (value: bigint, minimum: bigint, maximum: bigint): bigint =>
+  value < minimum ? minimum : value > maximum ? maximum : value;
+
+const nearby = (
+  selected: bigint,
+  minimum: bigint,
+  maximum: bigint,
+): bigint[] => {
+  const output: bigint[] = [];
+  for (let distance = BigInt(1); distance <= BigInt(32); ++distance) {
+    if (selected - distance >= minimum) output.push(selected - distance);
+    if (selected + distance <= maximum) output.push(selected + distance);
+  }
+  return output;
+};
+
+const unique = (values: bigint[]): bigint[] => [...new Set(values)];

package/src/internal/_randomNumber.ts

@@ -1,80 +1,97 @@
 import { OpenApi } from "@typia/interface";
 
+import { _randomMultiple } from "./_randomMultiple";
+
 export const _randomNumber = (schema: OpenApi.IJsonSchema.INumber): number => {
+  const lower: IBoundary | null = getLowerBoundary(schema);
+  const upper: IBoundary | null = getUpperBoundary(schema);
   const minimum: number =
-    schema.minimum ??
-    schema.exclusiveMinimum ??
-    (schema.multipleOf ?? 1) *
-      (schema.maximum === undefined && schema.exclusiveMaximum === undefined
-        ? 0
-        : (schema.maximum ?? schema.exclusiveMaximum!) - 100);
+    lower?.value ?? (upper === null ? 0 : upper.value - 100);
   const maximum: number =
-    schema.maximum ??
-    schema.exclusiveMaximum ??
-    (schema.multipleOf ?? 1) *
-      (schema.minimum === undefined && schema.exclusiveMinimum === undefined
-        ? 100
-        : (schema.minimum ?? schema.exclusiveMinimum!) + 100);
+    upper?.value ?? (lower === null ? 100 : lower.value + 100);
   if (minimum > maximum)
     throw new Error("Minimum value is greater than maximum value.");
   return schema.multipleOf === undefined
     ? scalar({
         minimum,
         maximum,
-        exclusiveMinimum: schema.exclusiveMinimum !== undefined,
-        exclusiveMaximum: schema.exclusiveMaximum !== undefined,
+        exclusiveMinimum: lower?.exclusive ?? false,
+        exclusiveMaximum: upper?.exclusive ?? false,
       })
-    : multiple({
+    : _randomMultiple({
         minimum,
         maximum,
         multipleOf: schema.multipleOf,
-        exclusiveMinimum: schema.exclusiveMinimum !== undefined,
-        exclusiveMaximum: schema.exclusiveMaximum !== undefined,
+        exclusiveMinimum: lower?.exclusive ?? false,
+        exclusiveMaximum: upper?.exclusive ?? false,
+        integer: false,
       });
 };
 
-const scalar = (p: {
+const scalar = (props: {
   minimum: number;
   maximum: number;
-  exclusiveMinimum?: boolean;
-  exclusiveMaximum?: boolean;
+  exclusiveMinimum: boolean;
+  exclusiveMaximum: boolean;
 }): number => {
-  if (p.minimum === p.maximum && (p.exclusiveMinimum || p.exclusiveMaximum))
-    throw new Error(
-      p.exclusiveMinimum
-        ? "Exclusive minimum value equals maximum value."
-        : "Exclusive maximum value equals minimum value.",
-    );
-  while (true) {
-    const value: number = Math.random() * (p.maximum - p.minimum) + p.minimum;
-    if (p.exclusiveMinimum && value === p.minimum) continue;
-    else if (p.exclusiveMaximum && value === p.maximum) continue;
-    return value;
+  if (
+    props.minimum === props.maximum &&
+    (props.exclusiveMinimum || props.exclusiveMaximum)
+  )
+    throw new Error("Exclusive numeric range is empty.");
+  const value: number =
+    Math.random() * (props.maximum - props.minimum) + props.minimum;
+  if (
+    (props.exclusiveMinimum && value === props.minimum) ||
+    (props.exclusiveMaximum && value === props.maximum)
+  ) {
+    const middle: number = props.minimum + (props.maximum - props.minimum) / 2;
+    if (middle <= props.minimum || middle >= props.maximum)
+      throw new Error("Exclusive numeric range has no representable value.");
+    return middle;
   }
+  return value;
 };
 
-const multiple = (p: {
-  minimum: number;
-  maximum: number;
-  multipleOf: number;
-  exclusiveMinimum?: boolean;
-  exclusiveMaximum?: boolean;
-}): number => {
-  let minimum = Math.ceil(p.minimum / p.multipleOf) * p.multipleOf;
-  let maximum = Math.floor(p.maximum / p.multipleOf) * p.multipleOf;
-  if (p.exclusiveMinimum === true && minimum % p.multipleOf === 0)
-    minimum += p.multipleOf;
-  if (p.exclusiveMaximum === true && maximum % p.multipleOf === 0)
-    maximum -= p.multipleOf;
-  if (minimum > maximum)
-    throw new Error(
-      "The range of the integer is smaller than the multipleOf value.",
-    );
-  const value: number = scalar({
-    minimum,
-    maximum,
-    exclusiveMinimum: p.exclusiveMinimum,
-    exclusiveMaximum: p.exclusiveMaximum,
-  });
-  return value - (value % p.multipleOf);
+const getLowerBoundary = (
+  schema: OpenApi.IJsonSchema.INumber,
+): IBoundary | null =>
+  selectBoundary(
+    schema.minimum === undefined
+      ? null
+      : { value: schema.minimum, exclusive: false },
+    schema.exclusiveMinimum === undefined
+      ? null
+      : { value: schema.exclusiveMinimum, exclusive: true },
+    Math.max,
+  );
+
+const getUpperBoundary = (
+  schema: OpenApi.IJsonSchema.INumber,
+): IBoundary | null =>
+  selectBoundary(
+    schema.maximum === undefined
+      ? null
+      : { value: schema.maximum, exclusive: false },
+    schema.exclusiveMaximum === undefined
+      ? null
+      : { value: schema.exclusiveMaximum, exclusive: true },
+    Math.min,
+  );
+
+const selectBoundary = (
+  x: IBoundary | null,
+  y: IBoundary | null,
+  compare: (x: number, y: number) => number,
+): IBoundary | null => {
+  if (x === null) return y;
+  if (y === null) return x;
+  if (x.value === y.value)
+    return { value: x.value, exclusive: x.exclusive || y.exclusive };
+  return compare(x.value, y.value) === x.value ? x : y;
 };
+
+interface IBoundary {
+  value: number;
+  exclusive: boolean;
+}