typia 5.3.11 → 5.3.12-dev.20240118

package/src/functional/Namespace/index.ts

@@ -0,0 +1,75 @@
+import { RandomGenerator } from "../../utils/RandomGenerator";
+
+import { IValidation } from "../../IValidation";
+import { TypeGuardError } from "../../TypeGuardError";
+import { $every } from "../$every";
+import { $guard } from "../$guard";
+import { $join } from "../$join";
+import { $report } from "../$report";
+import { is } from "../is";
+
+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 { 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

@@ -0,0 +1,15 @@
+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/misc.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,10 @@
+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,
+});