typia 6.6.2 → 6.7.0-dev.20240802

package/src/functional/$zigzag.ts

@@ -1,39 +1,39 @@
-export function $zigzag_encode(value: number): number;
-export function $zigzag_encode(value: bigint): bigint;
-export function $zigzag_encode(value: number | bigint): any {
-  // TODO: optimize (branchless solution exists)
-
-  if (typeof value === "bigint") {
-    if (value < BigInt(0)) {
-      value = -value;
-      return value * BigInt(2) - BigInt(1);
-    }
-    return value * BigInt(2);
-  }
-
-  if (value < 0) {
-    value = -value;
-    return value * 2 - 1;
-  }
-  return value * 2;
-}
-
-export function $zigzag_decode(value: number): number;
-export function $zigzag_decode(value: bigint): bigint;
-export function $zigzag_decode(value: number | bigint): any {
-  // TODO: optimize (branchless solution exists)
-
-  if (typeof value === "bigint") {
-    value = BigInt.asUintN(64, value);
-    if (value & BigInt(1)) {
-      return -(value + BigInt(1)) / BigInt(2);
-    }
-    return value / BigInt(2);
-  }
-
-  value = value >>> 0;
-  if (value & 1) {
-    return -(value + 1) / 2;
-  }
-  return value / 2;
-}
+export function $zigzag_encode(value: number): number;
+export function $zigzag_encode(value: bigint): bigint;
+export function $zigzag_encode(value: number | bigint): any {
+  // TODO: optimize (branchless solution exists)
+
+  if (typeof value === "bigint") {
+    if (value < BigInt(0)) {
+      value = -value;
+      return value * BigInt(2) - BigInt(1);
+    }
+    return value * BigInt(2);
+  }
+
+  if (value < 0) {
+    value = -value;
+    return value * 2 - 1;
+  }
+  return value * 2;
+}
+
+export function $zigzag_decode(value: number): number;
+export function $zigzag_decode(value: bigint): bigint;
+export function $zigzag_decode(value: number | bigint): any {
+  // TODO: optimize (branchless solution exists)
+
+  if (typeof value === "bigint") {
+    value = BigInt.asUintN(64, value);
+    if (value & BigInt(1)) {
+      return -(value + BigInt(1)) / BigInt(2);
+    }
+    return value / BigInt(2);
+  }
+
+  value = value >>> 0;
+  if (value & 1) {
+    return -(value + 1) / 2;
+  }
+  return value / 2;
+}

package/src/functional/IProtobufWriter.ts

@@ -1,18 +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;
-}
+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/functional/Namespace/functional.ts

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

package/src/functional/Namespace/http.ts

@@ -1,9 +1,9 @@
-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;
+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,76 +1,76 @@
-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 { 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,
-});
+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 { 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 +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}`),
-});
+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

@@ -1,14 +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}`),
-});
+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 +1,23 @@
-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}`),
-});
+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 +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),
-});
+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 +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,
-});
+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,
+});