typia 7.0.0-dev.20241002-2 → 7.0.0-dev.20241005

package/src/factories/NumericRangeFactory.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-
-import { ProtobufAtomic } from "../typings/ProtobufAtomic";
-
-import { ExpressionFactory } from "./ExpressionFactory";
-
-export namespace NumericRangeFactory {
-  export const number = (
-    type: ProtobufAtomic.Numeric,
-    input: ts.Expression,
-  ): ts.Expression => NumberPredicator[type](input);
-
-  export const bigint = (
-    type: ProtobufAtomic.BigNumeric,
-    input: ts.Expression,
-  ): ts.Expression => BigIntPredicator[type](input);
-}
-
-namespace NumberPredicator {
-  export const int32 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("-2147483648", "2147483647")(input),
-    );
-  export const uint32 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("0", "4294967295")(input),
-    );
-  export const int64 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("-9223372036854775808", "9223372036854775807")(input),
-    );
-  export const uint64 = (input: ts.Expression) =>
-    ts.factory.createLogicalAnd(
-      integer(input),
-      between("0", "18446744073709551615")(input),
-    );
-  export const float = (input: ts.Expression) =>
-    between("-1.175494351e38", "3.4028235e38")(input);
-  export const double = () => ts.factory.createTrue();
-}
-
-namespace BigIntPredicator {
-  export const int64 = () => ts.factory.createTrue();
-  export const uint64 = (input: ts.Expression) =>
-    ts.factory.createLessThanEquals(
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier("BigInt"),
-        undefined,
-        [ExpressionFactory.number(0)],
-      ),
-      input,
-    );
-}
-
-const integer = (input: ts.Expression) =>
-  ts.factory.createStrictEquality(
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier("Math.floor"),
-      undefined,
-      [input],
-    ),
-    input,
-  );
-
-const between = (x: string, y: string) => (input: ts.Expression) =>
-  ts.factory.createLogicalAnd(
-    ts.factory.createLessThanEquals(ts.factory.createIdentifier(x), input),
-    ts.factory.createLessThanEquals(input, ts.factory.createIdentifier(y)),
-  );
+import ts from "typescript";
+
+import { ProtobufAtomic } from "../typings/ProtobufAtomic";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+
+export namespace NumericRangeFactory {
+  export const number = (
+    type: ProtobufAtomic.Numeric,
+    input: ts.Expression,
+  ): ts.Expression => NumberPredicator[type](input);
+
+  export const bigint = (
+    type: ProtobufAtomic.BigNumeric,
+    input: ts.Expression,
+  ): ts.Expression => BigIntPredicator[type](input);
+}
+
+namespace NumberPredicator {
+  export const int32 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("-2147483648", "2147483647")(input),
+    );
+  export const uint32 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("0", "4294967295")(input),
+    );
+  export const int64 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("-9223372036854775808", "9223372036854775807")(input),
+    );
+  export const uint64 = (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+      integer(input),
+      between("0", "18446744073709551615")(input),
+    );
+  export const float = (input: ts.Expression) =>
+    between("-1.175494351e38", "3.4028235e38")(input);
+  export const double = () => ts.factory.createTrue();
+}
+
+namespace BigIntPredicator {
+  export const int64 = () => ts.factory.createTrue();
+  export const uint64 = (input: ts.Expression) =>
+    ts.factory.createLessThanEquals(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("BigInt"),
+        undefined,
+        [ExpressionFactory.number(0)],
+      ),
+      input,
+    );
+}
+
+const integer = (input: ts.Expression) =>
+  ts.factory.createStrictEquality(
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier("Math.floor"),
+      undefined,
+      [input],
+    ),
+    input,
+  );
+
+const between = (x: string, y: string) => (input: ts.Expression) =>
+  ts.factory.createLogicalAnd(
+    ts.factory.createLessThanEquals(ts.factory.createIdentifier(x), input),
+    ts.factory.createLessThanEquals(input, ts.factory.createIdentifier(y)),
+  );

package/src/factories/ProtobufFactory.ts

@@ -37,9 +37,10 @@ export namespace ProtobufFactory {
         },
       });
     if (result.success === false)
-      throw TransformerError.from(`typia.protobuf.${props.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.protobuf.${props.method}`,
+        errors: result.errors,
+      });
     return result.data;
   };
 

package/src/factories/TemplateFactory.ts

@@ -1,64 +1,64 @@
-import ts from "typescript";
-
-export namespace TemplateFactory {
-  export const generate = (expressions: ts.Expression[]): ts.Expression => {
-    if (expressions.every((exp) => ts.isStringLiteral(exp)))
-      return ts.factory.createStringLiteral(
-        (expressions as ts.StringLiteral[]).map((str) => str.text).join(""),
-      );
-
-    const iterator: IIterator = {
-      value: "",
-      index: 0,
-    };
-    gather({
-      expressions,
-      iterator,
-    });
-
-    const head: ts.TemplateHead = ts.factory.createTemplateHead(iterator.value);
-    const spans: ts.TemplateSpan[] = [];
-
-    while (true) {
-      const elem: ts.Expression = expressions[iterator.index++]!;
-      gather({
-        expressions,
-        iterator,
-      });
-
-      const broken: boolean = iterator.index === expressions.length;
-      spans.push(
-        ts.factory.createTemplateSpan(
-          elem,
-          broken
-            ? ts.factory.createTemplateTail(iterator.value)
-            : ts.factory.createTemplateMiddle(iterator.value),
-        ),
-      );
-      if (broken === true) break;
-    }
-    return ts.factory.createTemplateExpression(head, spans);
-  };
-
-  const gather = (props: {
-    expressions: ts.Expression[];
-    iterator: IIterator;
-  }): void => {
-    const found: number = props.expressions.findIndex(
-      (elem, index) =>
-        index >= props.iterator.index && !ts.isStringLiteral(elem),
-    );
-
-    const last: number = found !== -1 ? found : props.expressions.length;
-    props.iterator.value = props.expressions
-      .slice(props.iterator.index, last)
-      .map((elem) => (elem as ts.StringLiteral).text)
-      .reduce((x, y) => x + y, "");
-    props.iterator.index = last;
-  };
-
-  interface IIterator {
-    value: string;
-    index: number;
-  }
-}
+import ts from "typescript";
+
+export namespace TemplateFactory {
+  export const generate = (expressions: ts.Expression[]): ts.Expression => {
+    if (expressions.every((exp) => ts.isStringLiteral(exp)))
+      return ts.factory.createStringLiteral(
+        (expressions as ts.StringLiteral[]).map((str) => str.text).join(""),
+      );
+
+    const iterator: IIterator = {
+      value: "",
+      index: 0,
+    };
+    gather({
+      expressions,
+      iterator,
+    });
+
+    const head: ts.TemplateHead = ts.factory.createTemplateHead(iterator.value);
+    const spans: ts.TemplateSpan[] = [];
+
+    while (true) {
+      const elem: ts.Expression = expressions[iterator.index++]!;
+      gather({
+        expressions,
+        iterator,
+      });
+
+      const broken: boolean = iterator.index === expressions.length;
+      spans.push(
+        ts.factory.createTemplateSpan(
+          elem,
+          broken
+            ? ts.factory.createTemplateTail(iterator.value)
+            : ts.factory.createTemplateMiddle(iterator.value),
+        ),
+      );
+      if (broken === true) break;
+    }
+    return ts.factory.createTemplateExpression(head, spans);
+  };
+
+  const gather = (props: {
+    expressions: ts.Expression[];
+    iterator: IIterator;
+  }): void => {
+    const found: number = props.expressions.findIndex(
+      (elem, index) =>
+        index >= props.iterator.index && !ts.isStringLiteral(elem),
+    );
+
+    const last: number = found !== -1 ? found : props.expressions.length;
+    props.iterator.value = props.expressions
+      .slice(props.iterator.index, last)
+      .map((elem) => (elem as ts.StringLiteral).text)
+      .reduce((x, y) => x + y, "");
+    props.iterator.index = last;
+  };
+
+  interface IIterator {
+    value: string;
+    index: number;
+  }
+}

package/src/functional/$clone.ts

@@ -1,48 +1,48 @@
-import { Resolved } from "../Resolved";
-
-export const $clone = <T>(value: T): Resolved<T> =>
-  $cloneMain(value) as Resolved<T>;
-
-const $cloneMain = (value: any): any => {
-  if (value === undefined) return undefined;
-  else if (typeof value === "object")
-    if (value === null) return null;
-    else if (Array.isArray(value)) return value.map($cloneMain);
-    else if (value instanceof Date) return new Date(value);
-    else if (value instanceof Uint8Array) return new Uint8Array(value);
-    else if (value instanceof Uint8ClampedArray)
-      return new Uint8ClampedArray(value);
-    else if (value instanceof Uint16Array) return new Uint16Array(value);
-    else if (value instanceof Uint32Array) return new Uint32Array(value);
-    else if (value instanceof BigUint64Array) return new BigUint64Array(value);
-    else if (value instanceof Int8Array) return new Int8Array(value);
-    else if (value instanceof Int16Array) return new Int16Array(value);
-    else if (value instanceof Int32Array) return new Int32Array(value);
-    else if (value instanceof BigInt64Array) return new BigInt64Array(value);
-    else if (value instanceof Float32Array) return new Float32Array(value);
-    else if (value instanceof Float64Array) return new Float64Array(value);
-    else if (value instanceof ArrayBuffer) return value.slice(0);
-    else if (value instanceof SharedArrayBuffer) return value.slice(0);
-    else if (value instanceof DataView)
-      return new DataView(value.buffer.slice(0));
-    else if (typeof File !== "undefined" && value instanceof File)
-      return new File([value], value.name, { type: value.type });
-    else if (typeof Blob !== "undefined" && value instanceof Blob)
-      return new Blob([value], { type: value.type });
-    else if (value instanceof Set) return new Set([...value].map($cloneMain));
-    else if (value instanceof Map)
-      return new Map(
-        [...value].map(([k, v]) => [$cloneMain(k), $cloneMain(v)]),
-      );
-    else if (value instanceof WeakSet || value instanceof WeakMap)
-      throw new Error("WeakSet and WeakMap are not supported");
-    else if (value.valueOf() !== value) return $cloneMain(value.valueOf());
-    else
-      return Object.fromEntries(
-        Object.entries(value)
-          .map(([k, v]) => [k, $cloneMain(v)])
-          .filter(([, v]) => v !== undefined),
-      );
-  else if (typeof value === "function") return undefined;
-  return value;
-};
+import { Resolved } from "../Resolved";
+
+export const $clone = <T>(value: T): Resolved<T> =>
+  $cloneMain(value) as Resolved<T>;
+
+const $cloneMain = (value: any): any => {
+  if (value === undefined) return undefined;
+  else if (typeof value === "object")
+    if (value === null) return null;
+    else if (Array.isArray(value)) return value.map($cloneMain);
+    else if (value instanceof Date) return new Date(value);
+    else if (value instanceof Uint8Array) return new Uint8Array(value);
+    else if (value instanceof Uint8ClampedArray)
+      return new Uint8ClampedArray(value);
+    else if (value instanceof Uint16Array) return new Uint16Array(value);
+    else if (value instanceof Uint32Array) return new Uint32Array(value);
+    else if (value instanceof BigUint64Array) return new BigUint64Array(value);
+    else if (value instanceof Int8Array) return new Int8Array(value);
+    else if (value instanceof Int16Array) return new Int16Array(value);
+    else if (value instanceof Int32Array) return new Int32Array(value);
+    else if (value instanceof BigInt64Array) return new BigInt64Array(value);
+    else if (value instanceof Float32Array) return new Float32Array(value);
+    else if (value instanceof Float64Array) return new Float64Array(value);
+    else if (value instanceof ArrayBuffer) return value.slice(0);
+    else if (value instanceof SharedArrayBuffer) return value.slice(0);
+    else if (value instanceof DataView)
+      return new DataView(value.buffer.slice(0));
+    else if (typeof File !== "undefined" && value instanceof File)
+      return new File([value], value.name, { type: value.type });
+    else if (typeof Blob !== "undefined" && value instanceof Blob)
+      return new Blob([value], { type: value.type });
+    else if (value instanceof Set) return new Set([...value].map($cloneMain));
+    else if (value instanceof Map)
+      return new Map(
+        [...value].map(([k, v]) => [$cloneMain(k), $cloneMain(v)]),
+      );
+    else if (value instanceof WeakSet || value instanceof WeakMap)
+      throw new Error("WeakSet and WeakMap are not supported");
+    else if (value.valueOf() !== value) return $cloneMain(value.valueOf());
+    else
+      return Object.fromEntries(
+        Object.entries(value)
+          .map(([k, v]) => [k, $cloneMain(v)])
+          .filter(([, v]) => v !== undefined),
+      );
+  else if (typeof value === "function") return undefined;
+  return value;
+};

package/src/functional/$throws.ts

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

@@ -1,6 +1,5 @@
 import { RandomGenerator } from "../../utils/RandomGenerator";
 
-import { $every } from "../$every";
 import { $guard } from "../$guard";
 import { $join } from "../$join";
 import { $report } from "../$report";
@@ -21,7 +20,6 @@ export { is };
 export const assert = (method: string) => ({
   ...is(),
   join: $join,
-  every: $every,
   guard: $guard(`typia.${method}`),
   predicate: (
     matched: boolean,

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