typia 13.1.1 → 13.2.0

package/src/internal/_randomFormatIpv4.ts

@@ -1,7 +1,37 @@
 import { _randomInteger } from "./_randomInteger";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomComposition } from "./private/__randomComposition";
 
-export const _randomFormatIpv4 = (): string =>
-  new Array(4).fill(0).map(random).join(".");
+export const _randomFormatIpv4 = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return new Array(4).fill(0).map(random).join(".");
+  // Three dots plus four octets of one to three digits: `0.0.0.0` is the
+  // shortest address and `255.255.255.255` the longest, and every length
+  // between them is reached by choosing how many digits each octet spends.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, {
+      minimum: 4 * DIGITS_MIN + DOTS,
+      maximum: 4 * DIGITS_MAX + DOTS,
+      spread: 8,
+    }),
+  );
+  return __randomComposition({
+    total: length - DOTS,
+    count: 4,
+    minimum: DIGITS_MIN,
+    maximum: DIGITS_MAX,
+  })
+    .map(octet)
+    .join(".");
+};
+
+const DOTS = 3;
+const DIGITS_MIN = 1;
+const DIGITS_MAX = 3;
 
 const random = () =>
   _randomInteger({
@@ -9,3 +39,14 @@ const random = () =>
     minimum: 0,
     maximum: 255,
   });
+
+// An octet is bounded by 255, so a three-digit one starts at 100 and stops
+// there rather than at 999.
+const octet = (digits: number): string =>
+  String(
+    _randomInteger({
+      type: "integer",
+      minimum: digits === 1 ? 0 : Math.pow(10, digits - 1),
+      maximum: digits === 3 ? 255 : Math.pow(10, digits) - 1,
+    }),
+  );

package/src/internal/_randomFormatIpv6.ts

@@ -1,7 +1,61 @@
+import { _randomFormatIpv4 } from "./_randomFormatIpv4";
 import { _randomInteger } from "./_randomInteger";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomComposition } from "./private/__randomComposition";
 
-export const _randomFormatIpv6 = (): string =>
-  new Array(8).fill(0).map(random).join(":");
+export const _randomFormatIpv6 = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return new Array(GROUPS).fill(0).map(random).join(":");
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, {
+      minimum: SHORTEST,
+      maximum: LONGEST,
+      spread: 12,
+    }),
+  );
+  // `::` alone is the all-zero address, and the three forms below cover every
+  // length between it and the padded IPv4-suffixed address: a compressed prefix
+  // for the short ones, eight groups of one to four hexadecimal digits for the
+  // middle, and six groups plus a dotted-quad tail for the long ones.
+  if (length === SHORTEST) return "::";
+  if (length < GROUPS * DIGITS_MIN + COLONS) {
+    // `::` plus `count` groups spends one colon between each pair.
+    const count: number = Math.ceil((length - 1) / (DIGITS_MAX + 1));
+    return `::${compose(length - 1 - count, count)}`;
+  }
+  if (length <= GROUPS * DIGITS_MAX + COLONS)
+    return compose(length - COLONS, GROUPS);
+  // The dotted-quad tail is drawn at its longest so the six leading groups keep
+  // a composable number of digits.
+  const tail: string = _randomFormatIpv4({
+    minLength: IPV4_MAX,
+    maxLength: IPV4_MAX,
+  });
+  return `${compose(length - IPV4_MAX - EMBEDDED, EMBEDDED)}:${tail}`;
+};
+
+const GROUPS = 8;
+const COLONS = GROUPS - 1;
+const DIGITS_MIN = 1;
+const DIGITS_MAX = 4;
+const EMBEDDED = 6; // groups preceding a dotted-quad tail
+const IPV4_MAX = "255.255.255.255".length;
+const SHORTEST = "::".length;
+const LONGEST = EMBEDDED * DIGITS_MAX + EMBEDDED + IPV4_MAX;
+
+const compose = (digits: number, count: number): string =>
+  __randomComposition({
+    total: digits,
+    count,
+    minimum: DIGITS_MIN,
+    maximum: DIGITS_MAX,
+  })
+    .map(group)
+    .join(":");
 
 const random = () =>
   _randomInteger({
@@ -9,3 +63,14 @@ const random = () =>
     minimum: 0,
     maximum: 65_535,
   }).toString(16);
+
+const group = (digits: number): string => {
+  let text: string = "";
+  for (let i: number = 0; i < digits; ++i)
+    text += _randomInteger({
+      type: "integer",
+      minimum: 0,
+      maximum: 15,
+    }).toString(16);
+  return text;
+};

package/src/internal/_randomFormatIri.ts

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

package/src/internal/_randomFormatIriReference.ts

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

package/src/internal/_randomFormatJsonPointer.ts

@@ -1,7 +1,33 @@
 import { _randomString } from "./_randomString";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+  _randomSegmentLength,
+} from "./_randomStringLength";
 
-export const _randomFormatJsonPointer = (): string =>
-  `/components/schemas/${random()}`;
+export const _randomFormatJsonPointer = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return `${PREFIX}${random()}`;
+  // The `/components/schemas/` prefix (20 chars) is fixed; the reference token
+  // after it grows or shrinks to hit the requested length.
+  if (props.maxLength === undefined || props.maxLength >= PREFIX.length)
+    return `${PREFIX}${_randomSegmentLength(props, PREFIX.length, 10, 0)}`;
+  // Below that prefix a pointer still exists: the empty pointer addresses the
+  // whole document, and one `/`-prefixed token addresses a member of it.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, { minimum: 0, spread: 6 }),
+  );
+  return length === 0
+    ? ""
+    : `/${_randomString({
+        type: "string",
+        minLength: length - 1,
+        maxLength: length - 1,
+      })}`;
+};
+
+const PREFIX = "/components/schemas/";
 
 const random = () =>
   _randomString({ type: "string", minLength: 10, maxLength: 10 });

package/src/internal/_randomFormatPassword.ts

@@ -1,8 +1,13 @@
 import { _randomString } from "./_randomString";
+import { _ILengthProps } from "./_randomStringLength";
 
-export const _randomFormatPassword = (): string =>
-  _randomString({
-    type: "string",
-    minLength: 4,
-    maxLength: 16,
-  });
+export const _randomFormatPassword = (props?: _ILengthProps): string =>
+  _randomString(
+    props?.minLength === undefined && props?.maxLength === undefined
+      ? { type: "string", minLength: 4, maxLength: 16 }
+      : {
+          type: "string",
+          minLength: props?.minLength,
+          maxLength: props?.maxLength,
+        },
+  );

package/src/internal/_randomFormatRegex.ts

@@ -1,4 +1,25 @@
-export const _randomFormatRegex = (): string => FIXED;
+import { _randomString } from "./_randomString";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+
+export const _randomFormatRegex = (props?: _ILengthProps): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return FIXED;
+  // Every character `_randomString` emits is a literal in regular expression
+  // syntax, so a source of any length — including the empty source `new
+  // RegExp("")` accepts — compiles.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, { minimum: 0, spread: 16 }),
+  );
+  return _randomString({
+    type: "string",
+    minLength: length,
+    maxLength: length,
+  });
+};
 
 const FIXED =
   "/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/";

package/src/internal/_randomFormatRelativeJsonPointer.ts

@@ -1,8 +1,28 @@
 import { _randomInteger } from "./_randomInteger";
+import { _randomString } from "./_randomString";
+import {
+  _ILengthProps,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomNumeric } from "./private/__randomComposition";
 
-export const _randomFormatRelativeJsonPointer = (): string =>
-  `${_randomInteger({
-    type: "integer",
-    minimum: 0,
-    maximum: 10,
-  })}#`;
+export const _randomFormatRelativeJsonPointer = (
+  props?: _ILengthProps,
+): string => {
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return `${_randomInteger({ type: "integer", minimum: 0, maximum: 10 })}#`;
+  // The leading non-negative integer stands alone as a pointer, so a single
+  // digit is the shortest form; `#` names the key and a `/`-prefixed token names
+  // a member, which absorbs any remaining length.
+  const length: number = _randomLengthPick(
+    _randomLengthWindow(props, { minimum: 1, spread: 6 }),
+  );
+  if (length === 1) return __randomNumeric(1);
+  if (length === 2) return `${__randomNumeric(1)}#`;
+  return `${__randomNumeric(1)}/${_randomString({
+    type: "string",
+    minLength: length - 2,
+    maxLength: length - 2,
+  })}`;
+};

package/src/internal/_randomFormatTime.ts

@@ -1,14 +1,50 @@
 import { _randomInteger } from "./_randomInteger";
+import {
+  _ILengthProps,
+  _RANDOM_LENGTH_ERROR,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomDigits } from "./private/__randomComposition";
 
-export const _randomFormatTime = (): string =>
-  new Date(
-    _randomInteger({
-      type: "integer",
-      minimum: 0,
-      maximum: DAY,
-    }),
-  )
-    .toISOString()
-    .substring(11);
+export const _randomFormatTime = (props?: _ILengthProps): string => {
+  const clock = (): string =>
+    new Date(
+      _randomInteger({ type: "integer", minimum: 0, maximum: DAY }),
+    ).toISOString();
+  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.
+  const window = _randomLengthWindow(props, {
+    minimum: CLOCK + 1,
+    maximum: CLOCK + 1 + FRACTION_MAX + OFFSET,
+    spread: 6,
+  });
+  let length: number = _randomLengthPick(window);
+  if (length === CLOCK + 2)
+    length = window.high >= CLOCK + 3 ? CLOCK + 3 : CLOCK + 1;
+  if (length < window.low || length > window.high)
+    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()}`;
+};
 
 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(
+    _randomInteger({ type: "integer", minimum: 0, maximum: 23 }),
+  )}:${pad(_randomInteger({ type: "integer", minimum: 0, maximum: 59 }))}`;
+
+const pad = (value: number): string => String(value).padStart(2, "0");

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;
+}