typia 7.0.0-dev.20241003 → 7.0.0-dev.20241005

package/src/internal/$httpParameterNumber.ts

@@ -0,0 +1,7 @@
+export const $httpParameterNumber = (value: string) =>
+  value !== "null" ? toNumber(value) : null;
+
+const toNumber = (str: string): number | string => {
+  const value: number = Number(str);
+  return isNaN(value) ? str : value;
+};

package/src/internal/$httpParameterString.ts

@@ -0,0 +1,2 @@
+export const $httpParameterString = (value: string) =>
+  value !== "null" ? value : null;

package/src/internal/$httpQueryParseURLSearchParams.ts

@@ -0,0 +1,10 @@
+export const $httpQueryParseURLSearchParams = (
+  input: string | URLSearchParams,
+) => {
+  if (typeof input === "string") {
+    const index: number = input.indexOf("?");
+    input = index === -1 ? "" : input.substring(index + 1);
+    return new URLSearchParams(input);
+  }
+  return input;
+};

package/src/internal/$httpQueryReadArray.ts

@@ -0,0 +1,4 @@
+export const $httpQueryReadArray = (
+  input: any[],
+  alternative: null | undefined,
+) => (input.length ? input : alternative);

package/src/internal/$httpQueryReadBigint.ts

@@ -0,0 +1,12 @@
+export const $httpQueryReadBigint = (
+  str: string | null,
+): bigint | null | undefined =>
+  !!str?.length ? (str === "null" ? null : (toBigint(str) as any)) : undefined;
+
+const toBigint = (str: string): bigint | string => {
+  try {
+    return BigInt(str);
+  } catch {
+    return str;
+  }
+};

package/src/internal/$httpQueryReadBoolean.ts

@@ -0,0 +1,14 @@
+export const $httpQueryReadBoolean = (
+  str: string | null,
+): boolean | null | undefined =>
+  str === null
+    ? undefined
+    : str === "null"
+      ? null
+      : str.length === 0
+        ? true
+        : str === "true" || str === "1"
+          ? true
+          : str === "false" || str === "0"
+            ? false
+            : (str as any); // wrong type

package/src/internal/$httpQueryReadNumber.ts

@@ -0,0 +1,9 @@
+export const $httpQueryReadNumber = (
+  str: string | null,
+): number | null | undefined =>
+  !!str?.length ? (str === "null" ? null : (toNumber(str) as any)) : undefined;
+
+const toNumber = (str: string): number | string => {
+  const value: number = Number(str);
+  return isNaN(value) ? str : value;
+};

package/src/internal/$httpQueryReadString.ts

@@ -0,0 +1,4 @@
+export const $httpQueryReadString = (
+  str: string | null,
+): string | null | undefined =>
+  str === null ? undefined : str === "null" ? null : str;

package/src/internal/$isBetween.ts

@@ -0,0 +1,2 @@
+export const $isBetween = (value: number, minimum: number, maximum: number) =>
+  minimum <= value && value <= maximum;

package/src/internal/$isBigintString.ts

@@ -0,0 +1,8 @@
+export const $isBigintString = (str: string): boolean => {
+  try {
+    BigInt(str);
+    return true;
+  } catch {
+    return false;
+  }
+};

package/src/internal/$jsonStringifyNumber.ts

@@ -0,0 +1,12 @@
+import { TypeGuardError } from "../TypeGuardError";
+
+export const $jsonStringifyNumber = (value: number): number => {
+  if (isFinite(value) === false)
+    throw new TypeGuardError({
+      method: "typia.json.stringify",
+      expected: "number",
+      value,
+      message: "Error on typia.json.stringify(): infinite or not a number.",
+    });
+  return value;
+};

package/src/internal/$jsonStringifyRest.ts

@@ -0,0 +1,3 @@
+export const $jsonStringifyRest = (str: string): string => {
+  return str.length === 2 ? "" : "," + str.substring(1, str.length - 1);
+};

package/src/internal/$jsonStringifyString.ts

@@ -0,0 +1,43 @@
+/**
+ * In the past, name of `typia` was `typescript-json`, and supported
+ * JSON serialization by wrapping `fast-json-stringify. `typescript-json` was
+ * a helper library of `fast-json-stringify`, which can skip manual JSON schema
+ * definition just by putting pure TypeScript type.
+ *
+ * This `$string` function is a part of `fast-json-stringify` at that time, and
+ * still being used in `typia` for the string serialization.
+ *
+ * @internal
+ * @reference https://github.com/fastify/fast-json-stringify/blob/master/lib/serializer.js
+ * @blog https://dev.to/samchon/good-bye-typescript-is-ancestor-of-typia-20000x-faster-validator-49fi
+ */
+export const $jsonStringifyString = (str: string): string => {
+  const len = str.length;
+  let result = "";
+  let last = -1;
+  let point = 255;
+
+  // eslint-disable-next-line
+  for (var i = 0; i < len; i++) {
+    point = str.charCodeAt(i);
+    if (point < 32) {
+      return JSON.stringify(str);
+    }
+    if (point >= 0xd800 && point <= 0xdfff) {
+      // The current character is a surrogate.
+      return JSON.stringify(str);
+    }
+    if (
+      point === 0x22 || // '"'
+      point === 0x5c // '\'
+    ) {
+      last === -1 && (last = 0);
+      result += str.slice(last, i) + "\\";
+      last = i;
+    }
+  }
+
+  return (
+    (last === -1 && '"' + str + '"') || '"' + result + str.slice(last) + '"'
+  );
+};

package/src/internal/$jsonStringifyTail.ts

@@ -0,0 +1,2 @@
+export const $jsonStringifyTail = (str: string): string =>
+  str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;

package/src/internal/$llmApplicationFinalize.ts

@@ -0,0 +1,18 @@
+import { ILlmApplication } from "@samchon/openapi";
+
+import { LlmSchemaSeparator } from "@samchon/openapi/lib/utils/LlmSchemaSeparator";
+
+export const $llmApplicationFinalize = (
+  app: ILlmApplication,
+  options?: ILlmApplication.IOptions,
+): void => {
+  app.options = {
+    separate: options?.separate ?? null,
+  };
+  if (app.options.separate === null) return;
+  for (const func of app.functions)
+    func.separated = LlmSchemaSeparator.parameters({
+      parameters: func.parameters,
+      predicator: app.options.separate,
+    });
+};

package/src/internal/$miscCloneAny.ts

@@ -0,0 +1,48 @@
+import { Resolved } from "../Resolved";
+
+export const $miscCloneAny = <T>(value: T): Resolved<T> =>
+  $cloneMain(value) as Resolved<T>;
+
+const $cloneMain = (value: any): any => {
+  if (value === undefined) return undefined;
+  else if (typeof value === "object")
+    if (value === null) return null;
+    else if (Array.isArray(value)) return value.map($cloneMain);
+    else if (value instanceof Date) return new Date(value);
+    else if (value instanceof Uint8Array) return new Uint8Array(value);
+    else if (value instanceof Uint8ClampedArray)
+      return new Uint8ClampedArray(value);
+    else if (value instanceof Uint16Array) return new Uint16Array(value);
+    else if (value instanceof Uint32Array) return new Uint32Array(value);
+    else if (value instanceof BigUint64Array) return new BigUint64Array(value);
+    else if (value instanceof Int8Array) return new Int8Array(value);
+    else if (value instanceof Int16Array) return new Int16Array(value);
+    else if (value instanceof Int32Array) return new Int32Array(value);
+    else if (value instanceof BigInt64Array) return new BigInt64Array(value);
+    else if (value instanceof Float32Array) return new Float32Array(value);
+    else if (value instanceof Float64Array) return new Float64Array(value);
+    else if (value instanceof ArrayBuffer) return value.slice(0);
+    else if (value instanceof SharedArrayBuffer) return value.slice(0);
+    else if (value instanceof DataView)
+      return new DataView(value.buffer.slice(0));
+    else if (typeof File !== "undefined" && value instanceof File)
+      return new File([value], value.name, { type: value.type });
+    else if (typeof Blob !== "undefined" && value instanceof Blob)
+      return new Blob([value], { type: value.type });
+    else if (value instanceof Set) return new Set([...value].map($cloneMain));
+    else if (value instanceof Map)
+      return new Map(
+        [...value].map(([k, v]) => [$cloneMain(k), $cloneMain(v)]),
+      );
+    else if (value instanceof WeakSet || value instanceof WeakMap)
+      throw new Error("WeakSet and WeakMap are not supported");
+    else if (value.valueOf() !== value) return $cloneMain(value.valueOf());
+    else
+      return Object.fromEntries(
+        Object.entries(value)
+          .map(([k, v]) => [k, $cloneMain(v)])
+          .filter(([, v]) => v !== undefined),
+      );
+  else if (typeof value === "function") return undefined;
+  return value;
+};

package/src/internal/$notationAny.ts

@@ -0,0 +1,37 @@
+export const $notationAny = (rename: (str: string) => string) => {
+  const main = (input: any): any => {
+    if (typeof input === "object")
+      if (input === null) return null;
+      else if (Array.isArray(input)) return input.map(main);
+      else if (
+        input instanceof Boolean ||
+        input instanceof BigInt ||
+        input instanceof Number ||
+        input instanceof String
+      )
+        return input.valueOf();
+      else if (input instanceof Date) return new Date(input);
+      else if (
+        input instanceof Uint8Array ||
+        input instanceof Uint8ClampedArray ||
+        input instanceof Uint16Array ||
+        input instanceof Uint32Array ||
+        input instanceof BigUint64Array ||
+        input instanceof Int8Array ||
+        input instanceof Int16Array ||
+        input instanceof Int32Array ||
+        input instanceof BigInt64Array ||
+        input instanceof Float32Array ||
+        input instanceof Float64Array ||
+        input instanceof DataView
+      )
+        return input;
+      else return object(input);
+    return input;
+  };
+  const object = (input: Record<string, any>) =>
+    Object.fromEntries(
+      Object.entries(input).map(([key, value]) => [rename(key), main(value)]),
+    );
+  return main;
+};

package/src/internal/$notationCamel.ts

@@ -0,0 +1,13 @@
+import { $__notationCapitalize } from "./private/$__notationCapitalize";
+import { $__notationUnsnake } from "./private/$__notationUnsnake";
+
+export const $notationCamel = $__notationUnsnake({
+  plain: (str) =>
+    str.length
+      ? str === str.toUpperCase()
+        ? str.toLocaleLowerCase()
+        : `${str[0]!.toLowerCase()}${str.substring(1)}`
+      : str,
+  snake: (str, i) =>
+    i === 0 ? str.toLowerCase() : $__notationCapitalize(str.toLowerCase()),
+});

package/src/internal/$notationPascal.ts

@@ -0,0 +1,8 @@
+import { $__notationCapitalize } from "./private/$__notationCapitalize";
+import { $__notationUnsnake } from "./private/$__notationUnsnake";
+
+export const $notationPascal = $__notationUnsnake({
+  plain: (str) =>
+    str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
+  snake: $__notationCapitalize,
+});

package/src/{utils/NamingConvention/NamingConvention.ts → internal/$notationSnake.ts}

@@ -1,87 +1,43 @@
-import { StringUtil } from "../StringUtil";
-
-const unsnake =
-  (props: {
-    plain: (str: string) => string;
-    snake: (str: string, index: number) => string;
-  }) =>
-  (str: string): string => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    let prefix: string = "";
-    for (let i: number = 0; i < str.length; i++) {
-      if (str[i] === "_") prefix += "_";
-      else break;
-    }
-    if (prefix.length !== 0) str = str.substring(prefix.length);
-
-    const out = (s: string) => `${prefix}${s}`;
-    if (str.length === 0) return out("");
-
-    const items: string[] = str.split("_").filter((s) => s.length !== 0);
-    return items.length === 0
-      ? out("")
-      : items.length === 1
-        ? out(props.plain(items[0]!))
-        : out(items.map(props.snake).join(""));
-  };
-
-export function snake(str: string): string {
-  if (str.length === 0) return str;
-
-  // PREFIX
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  let prefix: string = "";
-  for (let i: number = 0; i < str.length; i++) {
-    if (str[i] === "_") prefix += "_";
-    else break;
-  }
-  if (prefix.length !== 0) str = str.substring(prefix.length);
-
-  const out = (s: string) => `${prefix}${s}`;
-
-  // SNAKE CASE
-  const items: string[] = str.split("_");
-  if (items.length > 1) return out(items.map((s) => s.toLowerCase()).join("_"));
-
-  // CAMEL OR PASCAL CASE
-  const indexes: number[] = [];
-  for (let i: number = 0; i < str.length; i++) {
-    const code: number = str.charCodeAt(i);
-    if (65 <= code && code <= 90) indexes.push(i);
-  }
-  for (let i: number = indexes.length - 1; i > 0; --i) {
-    const now: number = indexes[i]!;
-    const prev: number = indexes[i - 1]!;
-    if (now - prev === 1) indexes.splice(i, 1);
-  }
-  if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
-  if (indexes.length === 0) return str.toLowerCase();
-
-  let ret: string = "";
-  for (let i: number = 0; i < indexes.length; i++) {
-    const first: number = i === 0 ? 0 : indexes[i - 1]!;
-    const last: number = indexes[i]!;
-
-    ret += str.substring(first, last).toLowerCase();
-    ret += "_";
-  }
-  ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
-  return out(ret);
-}
-
-export const camel = unsnake({
-  plain: (str) =>
-    str.length
-      ? str === str.toUpperCase()
-        ? str.toLocaleLowerCase()
-        : `${str[0]!.toLowerCase()}${str.substring(1)}`
-      : str,
-  snake: (str, i) =>
-    i === 0 ? str.toLowerCase() : StringUtil.capitalize(str.toLowerCase()),
-});
-
-export const pascal = unsnake({
-  plain: (str) =>
-    str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
-  snake: StringUtil.capitalize,
-});
+export const $notationSnake = (str: string): string => {
+  if (str.length === 0) return str;
+
+  // PREFIX
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let prefix: string = "";
+  for (let i: number = 0; i < str.length; i++) {
+    if (str[i] === "_") prefix += "_";
+    else break;
+  }
+  if (prefix.length !== 0) str = str.substring(prefix.length);
+
+  const out = (s: string) => `${prefix}${s}`;
+
+  // SNAKE CASE
+  const items: string[] = str.split("_");
+  if (items.length > 1) return out(items.map((s) => s.toLowerCase()).join("_"));
+
+  // CAMEL OR PASCAL CASE
+  const indexes: number[] = [];
+  for (let i: number = 0; i < str.length; i++) {
+    const code: number = str.charCodeAt(i);
+    if (65 <= code && code <= 90) indexes.push(i);
+  }
+  for (let i: number = indexes.length - 1; i > 0; --i) {
+    const now: number = indexes[i]!;
+    const prev: number = indexes[i - 1]!;
+    if (now - prev === 1) indexes.splice(i, 1);
+  }
+  if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
+  if (indexes.length === 0) return str.toLowerCase();
+
+  let ret: string = "";
+  for (let i: number = 0; i < indexes.length; i++) {
+    const first: number = i === 0 ? 0 : indexes[i - 1]!;
+    const last: number = indexes[i]!;
+
+    ret += str.substring(first, last).toLowerCase();
+    ret += "_";
+  }
+  ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
+  return out(ret);
+};

package/src/internal/$randomArray.ts

@@ -0,0 +1,20 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomArray = <T>(
+  props: Omit<OpenApi.IJsonSchema.IArray, "type" | "items"> & {
+    element: (index: number, count: number) => T;
+  },
+) => {
+  const count: number = $randomInteger({
+    minimum: props.minItems ?? 0,
+    maximum: props.maxItems ?? (props.minItems ?? 0) + 5,
+  });
+  if (props.uniqueItems !== true)
+    return new Array(count).fill(null).map((_, i) => props.element(i, count));
+  const elements: Set<any> = new Set();
+  while (elements.size !== count)
+    elements.add(props.element(elements.size, count));
+  return Array.from(elements);
+};

package/src/internal/$randomBigint.ts

@@ -0,0 +1,15 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomBigint = (
+  props: Omit<OpenApi.IJsonSchema.IInteger, "type">,
+): bigint =>
+  BigInt(
+    $randomInteger({
+      minimum: props.minimum !== undefined ? Number(props.minimum) : undefined,
+      maximum: props.maximum !== undefined ? Number(props.maximum) : undefined,
+      exclusiveMinimum: props.exclusiveMinimum,
+      exclusiveMaximum: props.exclusiveMaximum,
+    }),
+  );

package/src/internal/$randomBoolean.ts

@@ -0,0 +1 @@
+export const $randomBoolean = (): boolean => Math.random() < 0.5;

package/src/internal/$randomByte.ts

@@ -0,0 +1,3 @@
+export const $randomByte = (): string => FIXED;
+
+const FIXED = "vt7ekz4lIoNTTS9sDQYdWKharxIFAR54+z/umIxSgUM=";

package/src/internal/$randomFormatDate.ts

@@ -0,0 +1,17 @@
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomFormatDate = (props?: {
+  minimum?: number;
+  maximum?: number;
+}) =>
+  new Date(
+    $randomInteger({
+      minimum: props?.minimum ?? 0,
+      maximum:
+        (props?.maximum ?? props?.minimum === undefined)
+          ? Date.now()
+          : props.minimum + 365 * 24 * 60 * 60 * 1_000,
+    }),
+  )
+    .toISOString()
+    .substring(0, 10);

package/src/internal/$randomFormatDatetime.ts

@@ -0,0 +1,15 @@
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomFormatDatetime = (props?: {
+  minimum?: number;
+  maximum?: number;
+}) =>
+  new Date(
+    $randomInteger({
+      minimum: props?.minimum ?? 0,
+      maximum:
+        (props?.maximum ?? props?.minimum === undefined)
+          ? Date.now()
+          : props.minimum + 365 * 24 * 60 * 60 * 1_000,
+    }),
+  ).toISOString();

package/src/internal/$randomFormatDuration.ts

@@ -0,0 +1,26 @@
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomFormatDuration = (): string => {
+  const period: string = durate([
+    ["Y", random(0, 100)],
+    ["M", random(0, 12)],
+    ["D", random(0, 31)],
+  ]);
+  const time: string = durate([
+    ["H", random(0, 24)],
+    ["M", random(0, 60)],
+    ["S", random(0, 60)],
+  ]);
+  if (period.length + time.length === 0) return "PT0S";
+  return `P${period}${time.length ? "T" : ""}${time}`;
+};
+const durate = (elements: [string, number][]) =>
+  elements
+    .filter(([_unit, value]) => value !== 0)
+    .map(([unit, value]) => `${value}${unit}`)
+    .join("");
+const random = (minimum: number, maximum: number) =>
+  $randomInteger({
+    minimum,
+    maximum,
+  });

package/src/internal/$randomFormatEmail.ts

@@ -0,0 +1,11 @@
+import { $randomString } from "./$randomString";
+
+export const $randomFormatEmail = (): string =>
+  `${random(10)}@${random(10)}.${random(3)}`;
+
+const random = (length: number) =>
+  $randomString({
+    type: "string",
+    minLength: length,
+    maxLength: length,
+  });

package/src/internal/$randomFormatHostname.ts

@@ -0,0 +1,6 @@
+import { $randomString } from "./$randomString";
+
+export const $randomFormatHostname = (): string => `${random(10)}.${random(3)}`;
+
+const random = (length: number) =>
+  $randomString({ type: "string", minLength: length, maxLength: length });

package/src/internal/$randomFormatIdnEmail.ts

@@ -0,0 +1,3 @@
+import { $randomFormatEmail } from "./$randomFormatEmail";
+
+export const $randomFormatIdnEmail = (): string => $randomFormatEmail();

package/src/internal/$randomFormatIdnHostname.ts

@@ -0,0 +1,3 @@
+import { $randomFormatHostname } from "./$randomFormatHostname";
+
+export const $randomFormatIdnHostname = (): string => $randomFormatHostname();

package/src/internal/$randomFormatIpv4.ts

@@ -0,0 +1,10 @@
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomFormatIpv4 = (): string =>
+  new Array(4).fill(0).map(random).join(".");
+
+const random = () =>
+  $randomInteger({
+    minimum: 0,
+    maximum: 255,
+  });

package/src/internal/$randomFormatIpv6.ts

@@ -0,0 +1,10 @@
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomFormatIpv6 = (): string =>
+  new Array(8).fill(0).map(random).join(":");
+
+const random = () =>
+  $randomInteger({
+    minimum: 0,
+    maximum: 65_535,
+  }).toString(16);

package/src/internal/$randomFormatIri.ts

@@ -0,0 +1,3 @@
+import { $randomFormatUrl } from "./$randomFormatUrl";
+
+export const $randomFormatIri = (): string => $randomFormatUrl();

package/src/internal/$randomFormatIriReference.ts

@@ -0,0 +1,3 @@
+import { $randomFormatUrl } from "./$randomFormatUrl";
+
+export const $randomFormatIriReference = (): string => $randomFormatUrl();

package/src/internal/$randomFormatJsonPointer.ts

@@ -0,0 +1,7 @@
+import { $randomString } from "./$randomString";
+
+export const $randomFormatJsonPointer = (): string =>
+  `/components/schemas/${random()}`;
+
+const random = () =>
+  $randomString({ type: "string", minLength: 10, maxLength: 10 });

package/src/internal/$randomFormatPassword.ts

@@ -0,0 +1,8 @@
+import { $randomString } from "./$randomString";
+
+export const $randomFormatPassword = (): string =>
+  $randomString({
+    type: "string",
+    minLength: 4,
+    maxLength: 16,
+  });

package/src/internal/$randomFormatRegex.ts

@@ -0,0 +1,4 @@
+export const $randomFormatRegex = (): string => FIXED;
+
+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

@@ -0,0 +1,8 @@
+import { $randomString } from "./$randomString";
+
+export const $randomFormatRelativeJsonPointer = (): string =>
+  `${$randomString({
+    type: "string",
+    minLength: 3,
+    maxLength: 10,
+  })}#`;

package/src/internal/$randomFormatTime.ts

@@ -0,0 +1,13 @@
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomFormatTime = (): string =>
+  new Date(
+    $randomInteger({
+      minimum: 0,
+      maximum: DAY,
+    }),
+  )
+    .toISOString()
+    .substring(11, 23);
+
+const DAY = 86_400_000;

package/src/internal/$randomFormatUri.ts

@@ -0,0 +1,3 @@
+import { $randomFormatUrl } from "./$randomFormatUrl";
+
+export const $randomFormatUri = (): string => $randomFormatUrl();

package/src/internal/$randomFormatUriReference.ts

@@ -0,0 +1,3 @@
+import { $randomFormatUrl } from "./$randomFormatUrl";
+
+export const $randomFormatUriReference = (): string => $randomFormatUrl();