typia 7.0.0-dev.20241005 → 7.0.0-dev.20241008

package/src/functional/Namespace/index.ts

@@ -1,75 +0,0 @@
-import { RandomGenerator } from "../../utils/RandomGenerator";
-
-import { $guard } from "../$guard";
-import { $join } from "../$join";
-import { $report } from "../$report";
-import { IValidation } from "../../IValidation";
-import { TypeGuardError } from "../../TypeGuardError";
-import { is } from "../is";
-
-export * as functional from "./functional";
-export * as json from "./json";
-export * as http from "./http";
-export * as notations from "./notations";
-export * as misc from "./misc";
-export * as protobuf from "./protobuf";
-export * as llm from "./llm";
-
-export { is };
-
-export const assert = (method: string) => ({
-  ...is(),
-  join: $join,
-  guard: $guard(`typia.${method}`),
-  predicate: (
-    matched: boolean,
-    exceptionable: boolean,
-    closure: () => Omit<TypeGuardError.IProps, "method">,
-  ): boolean => {
-    if (matched === false && exceptionable === true)
-      throw new TypeGuardError({
-        ...closure(),
-        method: `typia.${method}`,
-      });
-    return matched;
-  },
-});
-
-export const validate = () => ({
-  ...is(),
-  join: $join,
-  report: $report,
-  predicate:
-    (res: IValidation) =>
-    (
-      matched: boolean,
-      exceptionable: boolean,
-      closure: () => IValidation.IError,
-    ) => {
-      // CHECK FAILURE
-      if (matched === false && exceptionable === true)
-        (() => {
-          res.success &&= false;
-          const errorList = (res as IValidation.IFailure).errors;
-
-          // TRACE ERROR
-          const error = closure();
-          if (errorList.length) {
-            const last = errorList[errorList.length - 1]!.path;
-            if (
-              last.length >= error.path.length &&
-              last.substring(0, error.path.length) === error.path
-            )
-              return;
-          }
-          errorList.push(error);
-          return;
-        })();
-      return matched;
-    },
-});
-
-export const random = () => ({
-  generator: RandomGenerator,
-  pick: RandomGenerator.pick,
-});

package/src/functional/Namespace/json.ts

@@ -1,15 +0,0 @@
-import { $number } from "../$number";
-import { $rest } from "../$rest";
-import { $string } from "../$string";
-import { $tail } from "../$tail";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const stringify = (method: string) => ({
-  ...is(),
-  number: $number,
-  string: $string,
-  tail: $tail,
-  rest: $rest,
-  throws: $throws(`json.${method}`),
-});

package/src/functional/Namespace/llm.ts

@@ -1,20 +0,0 @@
-import { ILlmApplication } from "@samchon/openapi";
-
-import { LlmSchemaSeparator } from "@samchon/openapi/lib/utils/LlmSchemaSeparator";
-
-export const application = () => ({
-  finalize: (
-    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/functional/Namespace/misc.ts

@@ -1,14 +0,0 @@
-import { $any } from "../$any";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const clone = (method: string) => ({
-  ...is(),
-  throws: $throws(`misc.${method}`),
-  any: $any,
-});
-
-export const prune = (method: string) => ({
-  ...is(),
-  throws: $throws(`misc.${method}`),
-});

package/src/functional/Namespace/notations.ts

@@ -1,23 +0,0 @@
-import { NamingConvention } from "../../utils/NamingConvention";
-
-import { $convention } from "../$convention";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const camel = (method: string) => ({
-  ...base(method),
-  any: $convention(NamingConvention.camel),
-});
-export const pascal = (method: string) => ({
-  ...base(method),
-  any: $convention(NamingConvention.pascal),
-});
-export const snake = (method: string) => ({
-  ...base(method),
-  any: $convention(NamingConvention.snake),
-});
-
-const base = (method: string) => ({
-  ...is(),
-  throws: $throws(`notations.${method}`),
-});

package/src/functional/Namespace/protobuf.ts

@@ -1,20 +0,0 @@
-import { $ProtobufReader } from "../$ProtobufReader";
-import { $ProtobufSizer } from "../$ProtobufSizer";
-import { $ProtobufWriter } from "../$ProtobufWriter";
-import { $strlen } from "../$strlen";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const decode = (method: string) => ({
-  ...is(),
-  Reader: $ProtobufReader,
-  throws: $throws(`protobuf.${method}`),
-});
-
-export const encode = (method: string) => ({
-  ...is(),
-  Sizer: $ProtobufSizer,
-  Writer: $ProtobufWriter,
-  strlen: $strlen,
-  throws: $throws(method),
-});

package/src/functional/is.ts

@@ -1,10 +0,0 @@
-import { $is_between } from "./$is_between";
-import { $is_bigint_string } from "./$stoll";
-
-/**
- * @internal
- */
-export const is = () => ({
-  is_between: $is_between,
-  is_bigint_string: $is_bigint_string,
-});

package/src/programmers/helpers/RandomRanger.ts

@@ -1,225 +0,0 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-
-export namespace RandomRanger {
-  export interface IDefaults {
-    minimum: number;
-    maximum: number;
-    gap: number;
-  }
-
-  export const length = (props: {
-    coalesce: (method: string) => ts.Expression;
-    defaults: IDefaults;
-    accessors: length.IAccessors;
-    tags: IMetadataTypeTag[];
-  }): ts.Expression | undefined => {
-    const range = {
-      minimum: take({
-        kind: props.accessors.minimum,
-        tags: props.tags,
-      }),
-      maximum: take({
-        kind: props.accessors.maximum,
-        tags: props.tags,
-      }),
-    };
-    if (range.minimum === undefined && range.maximum === undefined)
-      return undefined;
-
-    if (range.maximum !== undefined && range.minimum === undefined) {
-      if (range.maximum <= 0) {
-        range.maximum = 0;
-        range.minimum = 0;
-      } else if (range.maximum < props.defaults.gap)
-        range.minimum = props.defaults.minimum === 0 ? 0 : 1;
-    }
-    range.minimum ??= props.defaults.minimum;
-    range.maximum ??= props.defaults.maximum;
-    if (range.maximum < range.minimum)
-      (range.maximum as number) += props.defaults.gap;
-
-    return ts.factory.createCallExpression(
-      props.coalesce("integer"),
-      undefined,
-      [
-        ExpressionFactory.number(range.minimum),
-        ExpressionFactory.number(range.maximum),
-      ],
-    );
-  };
-  export namespace length {
-    export interface IAccessors {
-      minimum: string;
-      maximum: string;
-    }
-  }
-
-  export const number = (props: {
-    config: number.IConfig;
-    defaults: IDefaults;
-    tags: IMetadataTypeTag[];
-  }): ts.Expression => {
-    const range = {
-      minimum: {
-        value:
-          take({
-            kind: "minimum",
-            tags: props.tags,
-          }) ??
-          take({
-            kind: "exclusiveMinimum",
-            tags: props.tags,
-          }),
-        exclusive:
-          take({
-            kind: "exclusiveMinimum",
-            tags: props.tags,
-          }) !== undefined,
-      },
-      maximum: {
-        value:
-          take({
-            kind: "maximum",
-            tags: props.tags,
-          }) ??
-          take({
-            tags: props.tags,
-            kind: "exclusiveMaximum",
-          }),
-        exclusive:
-          take({
-            kind: "exclusiveMaximum",
-            tags: props.tags,
-          }) !== undefined,
-      },
-      stepper: undefined,
-      multiply: take({
-        kind: "multipleOf",
-        tags: props.tags,
-      }),
-    };
-
-    //----
-    // MULTIPLIERS
-    //----
-    if (range.multiply !== undefined) {
-      const { minimum, maximum } = multiplier({
-        gap: props.defaults.gap,
-        range,
-        value: range.multiply,
-      });
-      return ts.factory.createMultiply(
-        props.config.transform(range.multiply),
-        props.config.setter([minimum, maximum]),
-      );
-    }
-
-    //----
-    // RANGE
-    //----
-    // INT
-    const integer = (value: number) => value === Math.floor(value);
-    if (props.config.type === "int" || props.config.type === "uint") {
-      if (range.minimum.value !== undefined) {
-        if (range.minimum.exclusive) {
-          range.minimum.exclusive = false;
-          if (integer(range.minimum.value)) range.minimum.value += 1;
-        }
-        range.minimum.value = Math.ceil(range.minimum.value);
-      }
-      if (range.maximum.value !== undefined) {
-        if (range.maximum.exclusive) {
-          range.maximum.exclusive = false;
-          if (integer(range.maximum.value)) range.maximum.value -= 1;
-        }
-        range.maximum.value = Math.floor(range.maximum.value);
-      }
-    }
-
-    // UNSIGNED INT
-    if (props.config.type === "uint") {
-      if (range.minimum.value === undefined) range.minimum.value = 0;
-      else if (range.minimum.value <= 0) {
-        range.minimum.value = 0;
-        range.minimum.exclusive = false;
-      }
-    }
-
-    const minimum =
-      range.minimum.value ??
-      (range.maximum.value !== undefined
-        ? range.maximum.value - props.defaults.gap
-        : props.defaults.minimum);
-    const maximum =
-      range.maximum.value ??
-      (range.minimum.value !== undefined
-        ? range.minimum.value + props.defaults.gap
-        : props.defaults.maximum);
-    return props.config.setter([minimum, maximum]);
-  };
-  export namespace number {
-    export interface IConfig {
-      setter: (args: number[]) => ts.Expression;
-      transform: (value: number) => ts.Expression;
-      type: "int" | "uint" | "double";
-    }
-  }
-}
-
-const take = (props: {
-  kind: string;
-  tags: IMetadataTypeTag[];
-}): number | undefined => {
-  const value: bigint | number | undefined = props.tags.find(
-    (t) =>
-      t.kind === props.kind &&
-      (typeof t.value === "number" || typeof t.value === "bigint"),
-  )?.value;
-  return value !== undefined ? Number(value) : undefined;
-};
-
-const multiplier = (props: {
-  range: IRange;
-  gap: number;
-  value: number;
-}): {
-  minimum: number;
-  maximum: number;
-} => {
-  const minimum: number =
-    props.range.minimum.value === undefined
-      ? 0
-      : (() => {
-          const x: number =
-            props.value * Math.ceil(props.range.minimum.value / props.value);
-          return props.range.minimum.exclusive &&
-            x === props.range.minimum.value
-            ? x + props.value
-            : x;
-        })() / props.value;
-  const maximum: number =
-    props.range.maximum.value === undefined
-      ? props.gap
-      : (() => {
-          const y: number =
-            props.value * Math.floor(props.range.maximum.value / props.value);
-          return props.range.maximum.exclusive &&
-            y === props.range.maximum.value
-            ? y - props.value
-            : y;
-        })() / props.value;
-  return { minimum, maximum };
-};
-
-interface IRange {
-  minimum: IScalar;
-  maximum: IScalar;
-}
-interface IScalar {
-  value?: undefined | number;
-  exclusive: boolean;
-}

package/src/programmers/internal/random_custom.ts

@@ -1,39 +0,0 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { LiteralFactory } from "../../factories/LiteralFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-
-import { Customizable } from "../../typings/Customizable";
-
-/**
- * @internal
- */
-export const random_custom = (props: {
-  accessor: (name: string) => ts.Expression;
-  type: keyof Customizable;
-  tags: IMetadataTypeTag[];
-  expression: ts.Expression;
-}) =>
-  ExpressionFactory.coalesce(
-    ts.factory.createCallChain(
-      ts.factory.createPropertyAccessChain(
-        props.accessor("customs"),
-        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-        ts.factory.createIdentifier(props.type),
-      ),
-      ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-      undefined,
-      [
-        LiteralFactory.generate(
-          props.tags.map((t) => ({
-            name: t.name,
-            kind: t.kind,
-            value: t.value,
-          })),
-        ),
-      ],
-    ),
-    props.expression,
-  );

package/src/utils/RandomGenerator/RandomGenerator.ts

@@ -1,119 +0,0 @@
-import RandExp from "randexp";
-
-const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
-
-/* -----------------------------------------------------------
-  REGULAR
------------------------------------------------------------ */
-export const boolean = () => Math.random() < 0.5;
-export const integer = (min?: number, max?: number) => {
-  min ??= 0;
-  max ??= 100;
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-};
-export const bigint = (min?: bigint, max?: bigint) =>
-  BigInt(integer(Number(min ?? BigInt(0)), Number(max ?? BigInt(100))));
-export const number = (min?: number, max?: number) => {
-  min ??= 0;
-  max ??= 100;
-  return Math.random() * (max - min) + min;
-};
-export const string = (length?: number): string =>
-  new Array(length ?? integer(5, 10))
-    .fill(0)
-    .map(() => ALPHABETS[integer(0, ALPHABETS.length - 1)])
-    .join("");
-
-export const array = <T>(
-  closure: (index: number) => T,
-  count?: number,
-  unique?: boolean,
-): T[] => {
-  count ??= length();
-  unique ??= false;
-  if (unique === false)
-    return new Array(count ?? length())
-      .fill(0)
-      .map((_e, index) => closure(index));
-  else {
-    const set = new Set<T>();
-    while (set.size < count) set.add(closure(set.size));
-    return Array.from(set);
-  }
-};
-export const pick = <T>(array: T[]): T => array[integer(0, array.length - 1)]!;
-export const length = () => integer(0, 3);
-export const pattern = (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();
-};
-
-/* -----------------------------------------------------------
-  SECIAL FORMATS
------------------------------------------------------------ */
-// SPECIAL CHARACTERS
-export const byte = () => "vt7ekz4lIoNTTS9sDQYdWKharxIFAR54+z/umIxSgUM=";
-export const password = () => string(integer(4, 16));
-export const regex = () =>
-  "/^(?:(?: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)$/";
-export const uuid = () =>
-  "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);
-  });
-
-// ADDRESSES
-export const email = () => `${string(10)}@${string(10)}.${string(3)}`;
-export const hostname = () => `${string(10)}.${string(3)}`;
-export const idnEmail = () => email();
-export const idnHostname = () => hostname();
-export const iri = () => url();
-export const iriReference = () => url();
-export const ipv4 = () => array(() => integer(0, 255), 4).join(".");
-export const ipv6 = (): string =>
-  array(() => integer(0, 65535).toString(16), 8).join(":");
-export const uri = () => url();
-export const uriReference = () => url();
-export const uriTemplate = () => url();
-export const url = () => `https://${string(10)}.${string(3)}`;
-
-// TIMESTAMPS
-export const datetime = (min?: number, max?: number) =>
-  new Date(
-    number(min ?? Date.now() - 30 * DAY, max ?? Date.now() + 7 * DAY),
-  ).toISOString();
-export const date = (min?: number, max?: number) =>
-  new Date(number(min ?? 0, max ?? Date.now() * 2))
-    .toISOString()
-    .substring(0, 10);
-export const time = () => new Date(number(0, DAY)).toISOString().substring(11);
-export const duration = () => {
-  const period: string = durate([
-    ["Y", integer(0, 100)],
-    ["M", integer(0, 12)],
-    ["D", integer(0, 31)],
-  ]);
-  const time: string = durate([
-    ["H", integer(0, 24)],
-    ["M", integer(0, 60)],
-    ["S", integer(0, 60)],
-  ]);
-  if (period.length + time.length === 0) return "PT0S";
-  return `P${period}${time.length ? "T" : ""}${time}`;
-};
-
-// POINTERS
-export const jsonPointer = () => `/components/schemas/${string(10)}`;
-export const relativeJsonPointer = () => `${integer(0, 10)}#`;
-
-const DAY = 86400000;
-const durate = (elements: [string, number][]) =>
-  elements
-    .filter(([_unit, value]) => value !== 0)
-    .map(([unit, value]) => `${value}${unit}`)
-    .join("");

package/src/utils/RandomGenerator/index.ts

@@ -1 +0,0 @@
-export * as RandomGenerator from "./RandomGenerator";