typia 7.0.0-dev.20241003 → 7.0.0-dev.20241007

package/src/functional/$HeadersReader/$HeadersReader.ts

@@ -1,26 +0,0 @@
-export const boolean = (value: string | undefined) =>
-  value !== undefined
-    ? value === "true"
-      ? true
-      : value === "false"
-        ? false
-        : value
-    : undefined;
-export const bigint = (value: string | undefined) =>
-  value !== undefined ? toBigint(value) : undefined;
-export const number = (value: string | undefined) =>
-  value !== undefined ? toNumber(value) : undefined;
-export const string = (value: string | undefined) => value;
-
-const toBigint = (str: string): bigint | string => {
-  try {
-    return BigInt(str);
-  } catch {
-    return str;
-  }
-};
-
-const toNumber = (str: string): number | string => {
-  const value: number = Number(str);
-  return isNaN(value) ? str : value;
-};

package/src/functional/$HeadersReader/index.ts

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

package/src/functional/$ParameterReader/$ParameterReader.ts

@@ -1,29 +0,0 @@
-export const boolean = (value: string) =>
-  value !== "null"
-    ? value === "true" || value === "1"
-      ? true
-      : value === "false" || value === "0"
-        ? false
-        : value
-    : null;
-
-export const bigint = (value: string) =>
-  value !== "null" ? toBigint(value) : null;
-
-export const number = (value: string) =>
-  value !== "null" ? toNumber(value) : null;
-
-export const string = (value: string) => (value !== "null" ? value : null);
-
-const toNumber = (str: string): number | string => {
-  const value: number = Number(str);
-  return isNaN(value) ? str : value;
-};
-
-const toBigint = (str: string): bigint | string => {
-  try {
-    return BigInt(str);
-  } catch {
-    return str;
-  }
-};

package/src/functional/$ParameterReader/index.ts

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

package/src/functional/$QueryReader/$QueryReader.ts

@@ -1,46 +0,0 @@
-export const boolean = (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
-
-export const number = (str: string | null): number | null | undefined =>
-  !!str?.length ? (str === "null" ? null : (toNumber(str) as any)) : undefined;
-
-export const bigint = (str: string | null): bigint | null | undefined =>
-  !!str?.length ? (str === "null" ? null : (toBigint(str) as any)) : undefined;
-
-export const string = (str: string | null): string | null | undefined =>
-  str === null ? undefined : str === "null" ? null : str;
-
-export const params = (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;
-};
-
-export const array = (input: any[], alternative: null | undefined) =>
-  input.length ? input : alternative;
-
-const toNumber = (str: string): number | string => {
-  const value: number = Number(str);
-  return isNaN(value) ? str : value;
-};
-
-const toBigint = (str: string): bigint | string => {
-  try {
-    return BigInt(str);
-  } catch {
-    return str;
-  }
-};

package/src/functional/$QueryReader/index.ts

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

package/src/functional/$any.ts

@@ -1,3 +0,0 @@
-import { $clone } from "./$clone";
-
-export const $any = (val: any): any => $clone(val);

package/src/functional/$dictionary.ts

@@ -1,22 +0,0 @@
-import { Customizable } from "../typings/Customizable";
-
-/**
- * @internal
- */
-const blackhole: any = {};
-
-export const $dictionary = (() => {
-  const glob: {
-    __typia_custom_validator: Map<
-      `${string}`,
-      Map<keyof Customizable, (tagText: string) => (value: any) => boolean>
-    >;
-  } =
-    typeof global === "object" &&
-    typeof global.process === "object" &&
-    typeof global.process.versions === "object" &&
-    typeof global.process.versions.node !== "undefined"
-      ? ((global ?? blackhole) as any)
-      : ((self ?? blackhole) as any);
-  return (glob.__typia_custom_validator ??= new Map());
-})();

package/src/functional/$every.ts

@@ -1,11 +0,0 @@
-import { TypeGuardError } from "../TypeGuardError";
-
-export const $every = <T>(
-  array: T[],
-  pred: (value: T, i: number) => null | Omit<TypeGuardError.IProps, "method">,
-): null | Omit<TypeGuardError.IProps, "method"> => {
-  let error: null | Omit<TypeGuardError.IProps, "method"> = null;
-  for (let i: number = 0; i < array.length; ++i)
-    if (null !== (error = pred(array[i]!, i))) return error;
-  return null;
-};

package/src/functional/$guard.ts

@@ -1,21 +0,0 @@
-import { TypeGuardError } from "../TypeGuardError";
-
-/**
- * @internal
- */
-export const $guard =
-  (method: string) =>
-  (
-    exceptionable: boolean,
-    props: Omit<TypeGuardError.IProps, "method">,
-    factory?: (props: TypeGuardError.IProps) => Error,
-  ): boolean => {
-    if (exceptionable === true)
-      throw (factory ?? ((props) => new TypeGuardError(props)))({
-        method,
-        path: props.path,
-        expected: props.expected,
-        value: props.value,
-      });
-    return false;
-  };

package/src/functional/$is_between.ts

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

package/src/functional/$strlen.ts

@@ -1,7 +0,0 @@
-export const $strlen = (s: string): number => {
-  let b: number;
-  let i: number;
-  let c: number;
-  for (b = i = 0; (c = s.charCodeAt(i++)); b += c >> 11 ? 3 : c >> 7 ? 2 : 1);
-  return b;
-};

package/src/functional/$throws.ts

@@ -1,10 +0,0 @@
-import { TypeGuardError } from "../TypeGuardError";
-
-export const $throws =
-  (method: string) =>
-  (props: Pick<TypeGuardError.IProps, "expected" | "value">) => {
-    throw new TypeGuardError({
-      ...props,
-      method: `typia.${method}`,
-    });
-  };

package/src/functional/Namespace/functional.ts

@@ -1,5 +0,0 @@
-import { TypeGuardError } from "../../TypeGuardError";
-
-export const functionalAssert = () => ({
-  errorFactory: (p: TypeGuardError.IProps) => new TypeGuardError(p),
-});

package/src/functional/Namespace/http.ts

@@ -1,9 +0,0 @@
-import { $FormDataReader } from "../$FormDataReader";
-import { $HeadersReader } from "../$HeadersReader";
-import { $ParameterReader } from "../$ParameterReader";
-import { $QueryReader } from "../$QueryReader";
-
-export const formData = () => $FormDataReader;
-export const headers = () => $HeadersReader;
-export const parameter = () => $ParameterReader;
-export const query = () => $QueryReader;

package/src/functional/Namespace/index.ts

@@ -1,77 +0,0 @@
-import { RandomGenerator } from "../../utils/RandomGenerator";
-
-import { $every } from "../$every";
-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,
-  every: $every,
-  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/helpers/disable_function_importer_declare.ts

@@ -1,33 +0,0 @@
-import ts from "typescript";
-
-import { FunctionImporter } from "./FunctionImporter";
-
-export const disable_function_importer_declare = (
-  importer: FunctionImporter,
-): FunctionImporter => disable(importer) as FunctionImporter;
-
-const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
-  method: importer.method,
-  empty: (): boolean => importer.empty(),
-  use: (name: string): ts.Identifier => importer.use(name),
-  useLocal: (name: string): string => importer.useLocal(name),
-  hasLocal: (name: string): boolean => importer.hasLocal(name),
-  declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
-  declareUnions: (): ts.Statement[] => [],
-  increment: (): number => importer.increment(),
-  emplaceUnion: (
-    prefix: string,
-    name: string,
-    factory: () => ts.ArrowFunction,
-  ): string => importer.emplaceUnion(prefix, name, factory),
-  emplaceVariable: (key, value) => importer.emplaceVariable(key, value),
-  trace: (): void => importer.trace(),
-});
-
-type MethodOnly<T> = {
-  [P in keyof T]: T[P] extends Function
-    ? T[P]
-    : P extends "method"
-      ? T[P]
-      : never;
-};