typia 5.5.8 → 5.5.9

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,15 +1,15 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-
-export namespace MetadataHelper {
-  export const literal_to_metadata = (key: string): Metadata => {
-    const metadata: Metadata = Metadata.initialize();
-    metadata.constants.push(
-      MetadataConstant.create({
-        type: "string",
-        values: [key],
-      }),
-    );
-    return metadata;
-  };
-}
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+
+export namespace MetadataHelper {
+  export const literal_to_metadata = (key: string): Metadata => {
+    const metadata: Metadata = Metadata.initialize();
+    metadata.constants.push(
+      MetadataConstant.create({
+        type: "string",
+        values: [key],
+      }),
+    );
+    return metadata;
+  };
+}

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

@@ -1,46 +1,46 @@
-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.tags ?? [],
-          }),
-      );
-      temp.tags = undefined;
-    }
-  }
-
-  // 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.tags ?? [],
+          }),
+      );
+      temp.tags = undefined;
+    }
+  }
+
+  // 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_array_type.ts

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