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

package/src/internal/$randomFormatUriTemplate.ts

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

package/src/internal/$randomFormatUrl.ts

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

package/src/internal/$randomInteger.ts

@@ -0,0 +1,44 @@
+import { OpenApi } from "@samchon/openapi";
+
+export const $randomInteger = (
+  props: Omit<OpenApi.IJsonSchema.IInteger, "type">,
+) => {
+  let minimum: number =
+    props.minimum ?? (props.maximum === undefined ? 0 : props.maximum - 100);
+  if (props.minimum !== undefined && props.exclusiveMinimum === true) minimum++;
+  let maximum: number =
+    props.maximum ?? (props.minimum === undefined ? 100 : props.minimum + 100);
+  if (props.maximum !== undefined && props.exclusiveMaximum === true) maximum--;
+  if (minimum > maximum)
+    throw new Error("Minimum value is greater than maximum value.");
+  return props.multipleOf === undefined
+    ? scalar({
+        minimum,
+        maximum,
+      })
+    : multiple({
+        minimum,
+        maximum,
+        multipleOf: props.multipleOf,
+      });
+};
+
+const scalar = (p: { minimum: number; maximum: number }): number =>
+  Math.floor(Math.random() * (p.maximum - p.minimum + 1)) + p.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.",
+    );
+  return scalar({
+    minimum,
+    maximum,
+  });
+};

package/src/internal/$randomNumber.ts

@@ -0,0 +1,71 @@
+import { OpenApi } from "@samchon/openapi";
+
+export const $randomNumber = (
+  props: Omit<OpenApi.IJsonSchema.INumber, "type">,
+): number => {
+  const minimum: number =
+    props.minimum ?? (props.maximum === undefined ? 0 : props.maximum - 100);
+  const maximum: number =
+    props.maximum ?? (props.minimum === undefined ? 100 : props.minimum + 100);
+  if (minimum > maximum)
+    throw new Error("Minimum value is greater than maximum value.");
+  return props.multipleOf === undefined
+    ? scalar({
+        minimum,
+        maximum,
+        exclusiveMinimum: props.exclusiveMinimum,
+        exclusiveMaximum: props.exclusiveMaximum,
+      })
+    : multiple({
+        minimum,
+        maximum,
+        multipleOf: props.multipleOf,
+        exclusiveMinimum: props.exclusiveMinimum,
+        exclusiveMaximum: props.exclusiveMaximum,
+      });
+};
+
+const scalar = (p: {
+  minimum: number;
+  maximum: number;
+  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;
+  }
+};
+
+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.",
+    );
+  return scalar({
+    minimum,
+    maximum,
+    exclusiveMinimum: p.exclusiveMinimum,
+    exclusiveMaximum: p.exclusiveMaximum,
+  });
+};

package/src/internal/$randomPattern.ts

@@ -0,0 +1,10 @@
+import RandExp from "randexp";
+
+export const $randomPattern = (regex: RegExp): string => {
+  const r: RandExp = new RandExp(regex);
+  for (let i: number = 0; i < 10; ++i) {
+    const str: string = r.gen();
+    if (regex.test(str)) return str;
+  }
+  return r.gen();
+};

package/src/internal/$randomPick.ts

@@ -0,0 +1,8 @@
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomPick = <T>(array: T[]): T => array[random(array)]!;
+const random = <T>(array: T[]) =>
+  $randomInteger({
+    minimum: 0,
+    maximum: array.length - 1,
+  });

package/src/internal/$randomString.ts

@@ -0,0 +1,24 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { $randomInteger } from "./$randomInteger";
+
+export const $randomString = (
+  props: Omit<OpenApi.IJsonSchema.IString, "format">,
+) => {
+  const length: number = $randomInteger({
+    minimum: props.minLength,
+    maximum: props.maxLength,
+  });
+  return new Array(length)
+    .fill(0)
+    .map(() => ALPHABETS[random()])
+    .join("");
+};
+
+const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
+
+const random = () =>
+  $randomInteger({
+    minimum: 0,
+    maximum: ALPHABETS.length - 1,
+  });

package/src/internal/$randomUuid.ts

@@ -0,0 +1,6 @@
+export const $random_uuid = (): 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);
+  });

package/src/internal/$throwTypeGuardError.ts

@@ -0,0 +1,5 @@
+import { TypeGuardError } from "../TypeGuardError";
+
+export const $throwTypeGuardError = (props: TypeGuardError.IProps) => {
+  throw new TypeGuardError(props);
+};

package/src/internal/$validateReport.ts

@@ -0,0 +1,13 @@
+import { IValidation } from "../IValidation";
+
+export const $validateReport = (array: IValidation.IError[]) => {
+  const reportable = (path: string): boolean => {
+    if (array.length === 0) return true;
+    const last: string = array[array.length - 1]!.path;
+    return path.length > last.length || last.substring(0, path.length) !== path;
+  };
+  return (exceptable: boolean, error: IValidation.IError): false => {
+    if (exceptable && reportable(error.path)) array.push(error);
+    return false;
+  };
+};

package/src/internal/private/$__IProtobufWriter.ts

@@ -0,0 +1,18 @@
+export interface $__IProtobufWriter {
+  bool(value: boolean): void;
+  int32(value: number): void;
+  sint32(value: number): void;
+  uint32(value: number): void;
+
+  int64(value: bigint | number): void;
+  sint64(value: bigint | number): void;
+  uint64(value: bigint | number): void;
+
+  float(value: number): void;
+  double(value: number): void;
+  bytes(value: Uint8Array): void;
+  string(value: string): void;
+
+  fork(): void;
+  ldelim(): void;
+}

package/src/internal/private/$__notationCapitalize.ts

@@ -0,0 +1,2 @@
+export const $__notationCapitalize = (str: string) =>
+  str.length ? str[0]!.toUpperCase() + str.slice(1).toLowerCase() : str;

package/src/internal/private/$__notationUnsnake.ts

@@ -0,0 +1,24 @@
+export const $__notationUnsnake =
+  (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(""));
+  };