typia 6.0.0-dev.20240122 → 6.0.0

package/src/functional/$ProtobufSizer.ts

@@ -1,10 +1,7 @@
 import { $strlen } from "./$strlen";
 import { IProtobufWriter } from "./IProtobufWriter";
 
-/**
- * @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedSizer.ts
- * @internal
- */
+/// @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedSizer.ts
 export class $ProtobufSizer implements IProtobufWriter {
   /**
    * Total length.
@@ -126,14 +123,14 @@ export class $ProtobufSizer implements IProtobufWriter {
       value < 0
         ? 10 // 10 bits with leading 1's
         : value < 0x80
-        ? 1
-        : value < 0x4000
-        ? 2
-        : value < 0x200000
-        ? 3
-        : value < 0x10000000
-        ? 4
-        : 5;
+          ? 1
+          : value < 0x4000
+            ? 2
+            : value < 0x200000
+              ? 3
+              : value < 0x10000000
+                ? 4
+                : 5;
   }
 
   private varint64(val: bigint): void {
@@ -146,12 +143,5 @@ export class $ProtobufSizer implements IProtobufWriter {
   }
 }
 
-/**
- * @internal
- */
-const ND07 = BigInt(7);
-
-/**
- * @internal
- */
-const NX7F = BigInt(0x7f);
+const ND07 = /** @__PURE__ */ BigInt(7);
+const NX7F = /** @__PURE__ */ BigInt(0x7f);

package/src/functional/$ProtobufWriter.ts

@@ -1,10 +1,7 @@
 import { $ProtobufSizer } from "./$ProtobufSizer";
 import { IProtobufWriter } from "./IProtobufWriter";
 
-/**
- * @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedWriter.ts
- * @internal
- */
+/// @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedWriter.ts
 export class $ProtobufWriter implements IProtobufWriter {
   /**
    * Related sizer
@@ -144,32 +141,10 @@ export class $ProtobufWriter implements IProtobufWriter {
   }
 }
 
-/**
- * @internal
- */
-const utf8 = new TextEncoder();
-
-/**
- * @internal
- */
-const ND01 = BigInt(1);
-
-/**
- * @internal
- */
-const ND07 = BigInt(7);
-
-/**
- * @internal
- */
-const ND63 = BigInt(63);
-
-/**
- * @internal
- */
-const NX7F = BigInt(0x7f);
-
-/**
- * @internal
- */
-const NX80 = BigInt(0x80);
+const utf8 = /** @__PURE__ */ new TextEncoder();
+
+const ND01 = /** @__PURE__ */ BigInt(1);
+const ND07 = /** @__PURE__ */ BigInt(7);
+const ND63 = /** @__PURE__ */ BigInt(63);
+const NX7F = /** @__PURE__ */ BigInt(0x7f);
+const NX80 = /** @__PURE__ */ BigInt(0x80);

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

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

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

package/src/functional/$any.ts

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

package/src/functional/$clone.ts

@@ -1,7 +1,4 @@
 import { Primitive } from "../Primitive";
 
-/**
- * @internal
- */
 export const $clone = <T>(value: T): Primitive<T> =>
-  value !== undefined ? JSON.parse(JSON.stringify(value)) : undefined;
+  JSON.parse(JSON.stringify(value));

package/src/functional/$convention.ts

@@ -1,6 +1,3 @@
-/**
- * @internal
- */
 export const $convention = (rename: (str: string) => string) => {
   const main = (input: any): any => {
     if (typeof input === "object")

package/src/functional/$dictionary.ts

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

@@ -0,0 +1,11 @@
+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,31 +1,17 @@
 import { TypeGuardError } from "../TypeGuardError";
 
-/* -----------------------------------------------------------
-    ASSERT V2 -> USE (NULL OR ERROR) CONDITION
------------------------------------------------------------ */
-// /**
-//  * @internal
-//  */
-// export const $guardV2 =
-//     (method: string) => (props: Omit<TypeGuardError.IProps, "method">) =>
-//         new TypeGuardError({
-//             method,
-//             path: props.path,
-//             expected: props.expected,
-//             value: props.value,
-//         });
-
-/* -----------------------------------------------------------
-    ASSERT V3 -> (CONDITION OR THROW(exceptable): FALSE)
------------------------------------------------------------ */
 /**
  * @internal
  */
 export const $guard =
   (method: string) =>
-  (exceptionable: boolean, props: Omit<TypeGuardError.IProps, "method">) => {
+  (
+    exceptionable: boolean,
+    props: Omit<TypeGuardError.IProps, "method">,
+    factory?: (props: TypeGuardError.IProps) => Error,
+  ): boolean => {
     if (exceptionable === true)
-      throw new TypeGuardError({
+      throw (factory ?? ((props) => new TypeGuardError(props)))({
         method,
         path: props.path,
         expected: props.expected,

package/src/functional/$is_between.ts

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

package/src/functional/$join.ts

@@ -1,23 +1,11 @@
-/**
- * @internal
- */
 export const $join = (str: string): string =>
   variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`;
 
-/**
- * @internal
- */
 const variable = (str: string): boolean =>
   reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
 
-/**
- * @internal
- */
 const reserved = (str: string): boolean => RESERVED.has(str);
 
-/**
- * @internal
- */
 const RESERVED: Set<string> = new Set([
   "break",
   "case",

package/src/functional/$number.ts

@@ -1,8 +1,5 @@
 import { TypeGuardError } from "../TypeGuardError";
 
-/**
- * @internal
- */
 export const $number = (value: number): number => {
   if (isFinite(value) === false)
     throw new TypeGuardError({

package/src/functional/$report.ts

@@ -1,8 +1,5 @@
 import { IValidation } from "../IValidation";
 
-/**
- * @internal
- */
 export const $report = (array: IValidation.IError[]) => {
   const reportable = (path: string): boolean => {
     if (array.length === 0) return true;

package/src/functional/$rest.ts

@@ -1,6 +1,3 @@
-/**
- * @internal
- */
 export const $rest = (str: string): string => {
   return str.length === 2 ? "" : "," + str.substring(1, str.length - 1);
 };

package/src/functional/$stoll.ts

@@ -1,6 +1,3 @@
-/**
- * @internal
- */
 export const $is_bigint_string = (str: string): boolean => {
   try {
     BigInt(str);

package/src/functional/$string.ts

@@ -7,22 +7,18 @@
  * This `$string` function is a part of `fast-json-stringify` at that time, and
  * still being used in `typia` for the string serialization.
  *
+ * @internal
  * @reference https://github.com/fastify/fast-json-stringify/blob/master/lib/serializer.js
  * @blog https://dev.to/samchon/good-bye-typescript-is-ancestor-of-typia-20000x-faster-validator-49fi
- * @internal
  */
 export const $string = (str: string): string => {
-  if (STR_ESCAPE.test(str) === false) return `"${str}"`;
-
-  const length: number = str.length;
-  if (length > 41) return JSON.stringify(str);
-
+  const len = str.length;
   let result = "";
   let last = -1;
   let point = 255;
 
   // eslint-disable-next-line
-  for (let i = 0; i < length; ++i) {
+  for (var i = 0; i < len; i++) {
     point = str.charCodeAt(i);
     if (point < 32) {
       return JSON.stringify(str);
@@ -45,6 +41,3 @@ export const $string = (str: string): string => {
     (last === -1 && '"' + str + '"') || '"' + result + str.slice(last) + '"'
   );
 };
-
-const STR_ESCAPE =
-  /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/;

package/src/functional/$strlen.ts

@@ -1,6 +1,3 @@
-/**
- * @internal
- */
 export const $strlen = (s: string): number => {
   let b: number;
   let i: number;

package/src/functional/$throws.ts

@@ -1,8 +1,5 @@
 import { TypeGuardError } from "../TypeGuardError";
 
-/**
- * @internal
- */
 export const $throws =
   (method: string) =>
   (props: Pick<TypeGuardError.IProps, "expected" | "value">) => {

package/src/functional/$varint.ts

@@ -0,0 +1,130 @@
+function EncodeVarNumber(
+  dst: Uint8Array,
+  offset: number,
+  value: number,
+): number {
+  value = (value | 0) >>> 0; // 32-bit integer
+
+  while (value > 127) {
+    dst[offset++] = (value & 0b01111111) | 0b10000000;
+    value >>>= 7;
+  }
+  dst[offset++] = value;
+
+  return offset;
+}
+
+function DecodeVarNumber(
+  buf: Uint8Array,
+  offset: number,
+): [value: number, offset: number] {
+  let value = 0;
+  let shift = 0;
+
+  while (true) {
+    const byte = buf[offset++]!;
+    value |= (byte & 0b01111111) << shift;
+    if (byte < 128) {
+      break;
+    }
+    shift += 7;
+  }
+
+  return [value | 0, offset];
+}
+
+function DecodeVarBigInt(
+  buf: Uint8Array,
+  offset: number,
+): [value: bigint, offset: number] {
+  let value = BigInt(0);
+  let shift = BigInt(0);
+
+  while (true) {
+    const byte = buf[offset++]!;
+    value |= BigInt(byte & 0b01111111) << shift;
+    if (byte < 128) {
+      break;
+    }
+    shift += BigInt(7);
+  }
+
+  return [BigInt.asIntN(64, value), offset];
+}
+
+export function $varint_decode_i32(
+  buf: Uint8Array,
+  offset: number,
+): [value: number, offset: number] {
+  const [v, o] = DecodeVarNumber(buf, offset);
+  return [v, o];
+}
+
+export function $varint_decode_u32(
+  buf: Uint8Array,
+  offset: number,
+): [value: number, offset: number] {
+  const [v, o] = DecodeVarNumber(buf, offset);
+  return [v >>> 0, o];
+}
+
+export function $varint_decode_i64(
+  buf: Uint8Array,
+  offset: number,
+): [value: bigint, offset: number] {
+  const [v, o] = DecodeVarBigInt(buf, offset);
+  return [v, o];
+}
+
+export function $varint_decode_u64(
+  buf: Uint8Array,
+  offset: number,
+): [value: bigint, offset: number] {
+  const [v, o] = DecodeVarBigInt(buf, offset);
+  return [BigInt.asUintN(64, v), o];
+}
+
+function EncodeVarBigInt(
+  dst: Uint8Array,
+  offset: number,
+  value: bigint,
+): number {
+  value = BigInt.asUintN(64, value);
+
+  while (value > BigInt(127)) {
+    dst[offset++] = Number(value & BigInt(0b01111111)) | 0b10000000;
+    value >>= BigInt(7);
+  }
+  dst[offset++] = Number(value);
+
+  return offset;
+}
+
+export function $varint_encode(
+  dst: Uint8Array,
+  offset: number,
+  value: number,
+): number;
+export function $varint_encode(
+  dst: Uint8Array,
+  offset: number,
+  value: bigint,
+): number;
+
+export function $varint_encode(
+  dst: Uint8Array,
+  offset: number,
+  value: number | bigint,
+): number {
+  if (typeof value === "bigint") {
+    offset = EncodeVarBigInt(dst, offset, value);
+  } else {
+    if (value < 0) {
+      // NOTE: Protocol Buffers signed varint encoding uses two's complement of 64-bit unsigned integers.
+      offset = EncodeVarBigInt(dst, offset, BigInt(value));
+    } else {
+      offset = EncodeVarNumber(dst, offset, value);
+    }
+  }
+  return offset;
+}

package/src/functional/$zigzag.ts

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

package/src/functional/IProtobufWriter.ts

@@ -1,6 +1,3 @@
-/**
- * @internal
- */
 export interface IProtobufWriter {
   bool(value: boolean): void;
   int32(value: number): void;

package/src/functional/Namespace/functional.ts

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

package/src/functional/Namespace/http.ts

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

package/src/functional/Namespace/index.ts

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

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}`),
+});