typia 6.10.0 → 6.10.1-dev.20240919

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/TemplateFactory.ts

@@ -1,56 +1,56 @@
-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 it: IIterator = {
-      value: "",
-      index: 0,
-    };
-    gather(expressions)(it);
-
-    const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
-    const spans: ts.TemplateSpan[] = [];
-
-    while (true) {
-      const elem: ts.Expression = expressions[it.index++]!;
-      gather(expressions)(it);
-
-      const broken: boolean = it.index === expressions.length;
-      spans.push(
-        ts.factory.createTemplateSpan(
-          elem,
-          broken
-            ? ts.factory.createTemplateTail(it.value)
-            : ts.factory.createTemplateMiddle(it.value),
-        ),
-      );
-      if (broken === true) break;
-    }
-    return ts.factory.createTemplateExpression(head, spans);
-  };
-
-  const gather =
-    (expressions: ts.Expression[]) =>
-    (it: IIterator): void => {
-      const found: number = expressions.findIndex(
-        (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
-      );
-
-      const last: number = found !== -1 ? found : expressions.length;
-      it.value = expressions
-        .slice(it.index, last)
-        .map((elem) => (elem as ts.StringLiteral).text)
-        .reduce((x, y) => x + y, "");
-      it.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 it: IIterator = {
+      value: "",
+      index: 0,
+    };
+    gather(expressions)(it);
+
+    const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
+    const spans: ts.TemplateSpan[] = [];
+
+    while (true) {
+      const elem: ts.Expression = expressions[it.index++]!;
+      gather(expressions)(it);
+
+      const broken: boolean = it.index === expressions.length;
+      spans.push(
+        ts.factory.createTemplateSpan(
+          elem,
+          broken
+            ? ts.factory.createTemplateTail(it.value)
+            : ts.factory.createTemplateMiddle(it.value),
+        ),
+      );
+      if (broken === true) break;
+    }
+    return ts.factory.createTemplateExpression(head, spans);
+  };
+
+  const gather =
+    (expressions: ts.Expression[]) =>
+    (it: IIterator): void => {
+      const found: number = expressions.findIndex(
+        (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
+      );
+
+      const last: number = found !== -1 ? found : expressions.length;
+      it.value = expressions
+        .slice(it.index, last)
+        .map((elem) => (elem as ts.StringLiteral).text)
+        .reduce((x, y) => x + y, "");
+      it.index = last;
+    };
+
+  interface IIterator {
+    value: string;
+    index: number;
+  }
+}

package/src/factories/ValueFactory.ts

@@ -1,12 +1,12 @@
-import ts from "typescript";
-
-export namespace ValueFactory {
-  export const NULL = () => ts.factory.createNull();
-  export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
-  export const BOOLEAN = (value: boolean) =>
-    value ? ts.factory.createTrue() : ts.factory.createFalse();
-  export const INPUT = (str: string = "input") =>
-    ts.factory.createIdentifier(str);
-  export const TYPEOF = (input: ts.Expression) =>
-    ts.factory.createTypeOfExpression(input);
-}
+import ts from "typescript";
+
+export namespace ValueFactory {
+  export const NULL = () => ts.factory.createNull();
+  export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
+  export const BOOLEAN = (value: boolean) =>
+    value ? ts.factory.createTrue() : ts.factory.createFalse();
+  export const INPUT = (str: string = "input") =>
+    ts.factory.createIdentifier(str);
+  export const TYPEOF = (input: ts.Expression) =>
+    ts.factory.createTypeOfExpression(input);
+}

package/src/factories/internal/metadata/MetadataHelper.ts

@@ -1,21 +1,21 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
-
-export namespace MetadataHelper {
-  export const literal_to_metadata = (key: string): Metadata => {
-    const metadata: Metadata = Metadata.initialize();
-    metadata.constants.push(
-      MetadataConstant.create({
-        type: "string",
-        values: [
-          MetadataConstantValue.create({
-            value: key,
-            tags: undefined,
-          }),
-        ],
-      }),
-    );
-    return metadata;
-  };
-}
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
+
+export namespace MetadataHelper {
+  export const literal_to_metadata = (key: string): Metadata => {
+    const metadata: Metadata = Metadata.initialize();
+    metadata.constants.push(
+      MetadataConstant.create({
+        type: "string",
+        values: [
+          MetadataConstantValue.create({
+            value: key,
+            tags: undefined,
+          }),
+        ],
+      }),
+    );
+    return metadata;
+  };
+}

package/src/factories/internal/metadata/emend_metadata_atomics.ts

@@ -1,45 +1,45 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-export const emend_metadata_atomics = (meta: Metadata) => {
-  // ATOMICS
-  for (const a of meta.atomics) {
-    if (is_not_pure(a)) continue;
-    const index: number = meta.constants.findIndex((c) => c.type === a.type);
-    if (index !== -1) meta.constants.splice(index, 1);
-  }
-
-  // BOOLEAN
-  {
-    const index: number = meta.constants.findIndex((c) => c.type === "boolean");
-    if (index !== -1 && meta.constants[index]!.values.length === 2) {
-      const temp = meta.constants.splice(index, 1)[0]!;
-      ArrayUtil.take(
-        meta.atomics,
-        (a) => a.type === "boolean",
-        () =>
-          MetadataAtomic.create({
-            type: "boolean" as const,
-            tags: temp.values[0]!.tags ?? [],
-          }),
-      );
-    }
-  }
-
-  // TEMPLATE
-  if (meta.templates.length) {
-    const atomic: MetadataAtomic | undefined = meta.atomics.find(
-      (a) => a.type === "string",
-    );
-    if (atomic !== undefined && false === is_not_pure(atomic))
-      meta.templates.splice(0, meta.templates.length);
-  }
-};
-
-const is_not_pure = (atomic: MetadataAtomic): boolean =>
-  atomic.tags.length !== 0 &&
-  atomic.tags.every(
-    (row) => row.length !== 0 && row.every((c) => !!c.validate?.length),
-  );
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+export const emend_metadata_atomics = (meta: Metadata) => {
+  // ATOMICS
+  for (const a of meta.atomics) {
+    if (is_not_pure(a)) continue;
+    const index: number = meta.constants.findIndex((c) => c.type === a.type);
+    if (index !== -1) meta.constants.splice(index, 1);
+  }
+
+  // BOOLEAN
+  {
+    const index: number = meta.constants.findIndex((c) => c.type === "boolean");
+    if (index !== -1 && meta.constants[index]!.values.length === 2) {
+      const temp = meta.constants.splice(index, 1)[0]!;
+      ArrayUtil.take(
+        meta.atomics,
+        (a) => a.type === "boolean",
+        () =>
+          MetadataAtomic.create({
+            type: "boolean" as const,
+            tags: temp.values[0]!.tags ?? [],
+          }),
+      );
+    }
+  }
+
+  // TEMPLATE
+  if (meta.templates.length) {
+    const atomic: MetadataAtomic | undefined = meta.atomics.find(
+      (a) => a.type === "string",
+    );
+    if (atomic !== undefined && false === is_not_pure(atomic))
+      meta.templates.splice(0, meta.templates.length);
+  }
+};
+
+const is_not_pure = (atomic: MetadataAtomic): boolean =>
+  atomic.tags.length !== 0 &&
+  atomic.tags.every(
+    (row) => row.length !== 0 && row.every((c) => !!c.validate?.length),
+  );

package/src/factories/internal/metadata/emplace_metadata_alias.ts

@@ -1,41 +1,41 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_alias =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    type: ts.Type,
-    nullable: boolean,
-    explore: MetadataFactory.IExplore,
-  ): MetadataAlias => {
-    // CHECK EXISTENCE
-    const [alias, newbie, closure] = collection.emplaceAlias(
-      checker,
-      type,
-      type.aliasSymbol!,
-    );
-    ArrayUtil.add(alias.nullables, nullable);
-    if (newbie === false) return alias;
-
-    // CONSTRUCT VALUE TYPE
-    const value: Metadata = explore_metadata(checker)(options)(collection)(
-      errors,
-    )(type, {
-      ...explore,
-      escaped: false,
-      aliased: true,
-    });
-    closure(value);
-    return alias;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_alias =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    type: ts.Type,
+    nullable: boolean,
+    explore: MetadataFactory.IExplore,
+  ): MetadataAlias => {
+    // CHECK EXISTENCE
+    const [alias, newbie, closure] = collection.emplaceAlias(
+      checker,
+      type,
+      type.aliasSymbol!,
+    );
+    ArrayUtil.add(alias.nullables, nullable);
+    if (newbie === false) return alias;
+
+    // CONSTRUCT VALUE TYPE
+    const value: Metadata = explore_metadata(checker)(options)(collection)(
+      errors,
+    )(type, {
+      ...explore,
+      escaped: false,
+      aliased: true,
+    });
+    closure(value);
+    return alias;
+  };

package/src/factories/internal/metadata/emplace_metadata_tuple.ts

@@ -1,57 +1,57 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_tuple =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    type: ts.TupleType,
-    nullable: boolean,
-    explore: MetadataFactory.IExplore,
-  ): MetadataTupleType => {
-    // CHECK EXISTENCE
-    const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
-    ArrayUtil.add(tuple.nullables, nullable);
-    if (newbie === false) return tuple;
-
-    // CONSTRUCT ELEMENT TYPES
-    const flagList: readonly ts.ElementFlags[] =
-      type.elementFlags ?? (type.target as ts.TupleType)?.elementFlags ?? [];
-    const elements: Metadata[] = checker
-      .getTypeArguments(type as ts.TypeReference)
-      .map((elem, i) => {
-        const child: Metadata = explore_metadata(checker)(options)(collection)(
-          errors,
-        )(elem, {
-          ...explore,
-          nested: tuple,
-          aliased: false,
-          escaped: false,
-        });
-
-        // CHECK OPTIONAL
-        const flag: ts.ElementFlags | undefined = flagList[i];
-        if (flag === ts.ElementFlags.Optional) Writable(child).optional = true;
-
-        // REST TYPE
-        if (flag !== ts.ElementFlags.Rest) return child;
-        const wrapper: Metadata = Metadata.initialize();
-        Writable(wrapper).rest = child;
-        return wrapper;
-      });
-    closure(elements);
-
-    return tuple;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_tuple =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    type: ts.TupleType,
+    nullable: boolean,
+    explore: MetadataFactory.IExplore,
+  ): MetadataTupleType => {
+    // CHECK EXISTENCE
+    const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
+    ArrayUtil.add(tuple.nullables, nullable);
+    if (newbie === false) return tuple;
+
+    // CONSTRUCT ELEMENT TYPES
+    const flagList: readonly ts.ElementFlags[] =
+      type.elementFlags ?? (type.target as ts.TupleType)?.elementFlags ?? [];
+    const elements: Metadata[] = checker
+      .getTypeArguments(type as ts.TypeReference)
+      .map((elem, i) => {
+        const child: Metadata = explore_metadata(checker)(options)(collection)(
+          errors,
+        )(elem, {
+          ...explore,
+          nested: tuple,
+          aliased: false,
+          escaped: false,
+        });
+
+        // CHECK OPTIONAL
+        const flag: ts.ElementFlags | undefined = flagList[i];
+        if (flag === ts.ElementFlags.Optional) Writable(child).optional = true;
+
+        // REST TYPE
+        if (flag !== ts.ElementFlags.Rest) return child;
+        const wrapper: Metadata = Metadata.initialize();
+        Writable(wrapper).rest = child;
+        return wrapper;
+      });
+    closure(elements);
+
+    return tuple;
+  };