typia 5.5.7 → 5.5.8

package/src/programmers/helpers/UnionPredicator.ts

@@ -1,77 +1,77 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-import { MapUtil } from "../../utils/MapUtil";
-
-export namespace UnionPredicator {
-  export interface ISpecialized {
-    index: number;
-    object: MetadataObject;
-    property: MetadataProperty;
-    neighbour: boolean;
-  }
-
-  export const object = (targets: MetadataObject[]): Array<ISpecialized> => {
-    // PROPERTY MATRIX
-    const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
-    for (const obj of targets)
-      for (const prop of obj.properties) {
-        const key: string | null = prop.key.getSoleLiteral();
-        if (key !== null)
-          MapUtil.take(matrix)(key, () =>
-            ArrayUtil.repeat(targets.length, () => null),
-          );
-      }
-    targets.forEach((obj, i) => {
-      for (const prop of obj.properties) {
-        const key: string | null = prop.key.getSoleLiteral();
-        if (key !== null) matrix.get(key)![i] = prop;
-      }
-    });
-
-    // EXPLORE SPECIALIZERS
-    const output: ISpecialized[] = [];
-    targets.forEach((obj, i) => {
-      const children: ISpecializedProperty[] = [];
-      obj.properties.forEach((prop) => {
-        // MUST BE REQUIRED
-        if (prop.value.isRequired() === false) return;
-        const key: string | null = prop.key.getSoleLiteral();
-        if (key === null) return;
-
-        // FIND NEIGHBORHOOD PROPERTIES
-        const neighbors: MetadataProperty[] = matrix
-          .get(key)!
-          .filter((oppo, k) => i !== k && oppo !== null) as MetadataProperty[];
-
-        // NO NEIGHBORHOOD
-        const unique: boolean =
-          neighbors.length === 0 ||
-          neighbors.every((n) => !Metadata.intersects(prop.value, n.value));
-        if (unique === true)
-          children.push({
-            property: prop,
-            neighbour: neighbors.length !== 0,
-          });
-      });
-      if (children.length === 0) return;
-
-      const top: ISpecializedProperty =
-        children.find((child) => child.property.value.isConstant()) ||
-        children[0]!;
-      output.push({
-        index: i,
-        object: obj,
-        ...top,
-      });
-    });
-    return output;
-  };
-}
-
-interface ISpecializedProperty {
-  property: MetadataProperty;
-  neighbour: boolean;
-}
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { MapUtil } from "../../utils/MapUtil";
+
+export namespace UnionPredicator {
+  export interface ISpecialized {
+    index: number;
+    object: MetadataObject;
+    property: MetadataProperty;
+    neighbour: boolean;
+  }
+
+  export const object = (targets: MetadataObject[]): Array<ISpecialized> => {
+    // PROPERTY MATRIX
+    const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
+    for (const obj of targets)
+      for (const prop of obj.properties) {
+        const key: string | null = prop.key.getSoleLiteral();
+        if (key !== null)
+          MapUtil.take(matrix)(key, () =>
+            ArrayUtil.repeat(targets.length, () => null),
+          );
+      }
+    targets.forEach((obj, i) => {
+      for (const prop of obj.properties) {
+        const key: string | null = prop.key.getSoleLiteral();
+        if (key !== null) matrix.get(key)![i] = prop;
+      }
+    });
+
+    // EXPLORE SPECIALIZERS
+    const output: ISpecialized[] = [];
+    targets.forEach((obj, i) => {
+      const children: ISpecializedProperty[] = [];
+      obj.properties.forEach((prop) => {
+        // MUST BE REQUIRED
+        if (prop.value.isRequired() === false) return;
+        const key: string | null = prop.key.getSoleLiteral();
+        if (key === null) return;
+
+        // FIND NEIGHBORHOOD PROPERTIES
+        const neighbors: MetadataProperty[] = matrix
+          .get(key)!
+          .filter((oppo, k) => i !== k && oppo !== null) as MetadataProperty[];
+
+        // NO NEIGHBORHOOD
+        const unique: boolean =
+          neighbors.length === 0 ||
+          neighbors.every((n) => !Metadata.intersects(prop.value, n.value));
+        if (unique === true)
+          children.push({
+            property: prop,
+            neighbour: neighbors.length !== 0,
+          });
+      });
+      if (children.length === 0) return;
+
+      const top: ISpecializedProperty =
+        children.find((child) => child.property.value.isConstant()) ||
+        children[0]!;
+      output.push({
+        index: i,
+        object: obj,
+        ...top,
+      });
+    });
+    return output;
+  };
+}
+
+interface ISpecializedProperty {
+  property: MetadataProperty;
+  neighbour: boolean;
+}

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -27,6 +27,6 @@ type MethodOnly<T> = {
   [P in keyof T]: T[P] extends Function
     ? T[P]
     : P extends "method"
-    ? T[P]
-    : never;
+      ? T[P]
+      : never;
 };

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -1,87 +1,87 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
-
-export namespace HttpAssertFormDataProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode("FormData"),
-          ),
-          AssertProgrammer.Guardian.parameter(init),
-        ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Resolved"),
-          [
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
-            ),
-          ],
-          false,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "decode",
-            HttpFormDataProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("decode"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("assert"),
-                undefined,
-                [
-                  ts.factory.createIdentifier("output"),
-                  AssertProgrammer.Guardian.identifier(),
-                ],
-              ),
-              TypeFactory.keyword("any"),
-            ),
-          ),
-        ]),
-      );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
+
+export namespace HttpAssertFormDataProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode("FormData"),
+          ),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "decode",
+            HttpFormDataProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
+              ),
+              TypeFactory.keyword("any"),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -1,89 +1,89 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-
-export namespace HttpAssertHeadersProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(
-              HttpHeadersProgrammer.INPUT_TYPE,
-            ),
-          ),
-          AssertProgrammer.Guardian.parameter(init),
-        ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Resolved"),
-          [
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
-            ),
-          ],
-          false,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "decode",
-            HttpHeadersProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("decode"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("assert"),
-                undefined,
-                [
-                  ts.factory.createIdentifier("output"),
-                  AssertProgrammer.Guardian.identifier(),
-                ],
-              ),
-              TypeFactory.keyword("any"),
-            ),
-          ),
-        ]),
-      );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+
+export namespace HttpAssertHeadersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(
+              HttpHeadersProgrammer.INPUT_TYPE,
+            ),
+          ),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "decode",
+            HttpHeadersProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
+              ),
+              TypeFactory.keyword("any"),
+            ),
+          ),
+        ]),
+      );
+}