typia 5.3.5-dev.20231206 → 5.3.5

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

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { FunctionImporter } from "./FunctionImporeter";
-
-export const disable_function_importer_declare = (
-  importer: FunctionImporter,
-): FunctionImporter => disable(importer) as FunctionImporter;
-
-const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
-  method: importer.method,
-  empty: (): boolean => importer.empty(),
-  use: (name: string): ts.Identifier => importer.use(name),
-  useLocal: (name: string): string => importer.useLocal(name),
-  hasLocal: (name: string): boolean => importer.hasLocal(name),
-  declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
-  declareUnions: (): ts.Statement[] => [],
-  increment: (): number => importer.increment(),
-  emplaceUnion: (
-    prefix: string,
-    name: string,
-    factory: () => ts.ArrowFunction,
-  ): string => importer.emplaceUnion(prefix, name, factory),
-  trace: (): void => importer.trace(),
-});
-
-type MethodOnly<T> = {
-  [P in keyof T]: T[P] extends Function
-    ? T[P]
-    : P extends "method"
-    ? T[P]
-    : never;
-};
+import ts from "typescript";
+
+import { FunctionImporter } from "./FunctionImporeter";
+
+export const disable_function_importer_declare = (
+  importer: FunctionImporter,
+): FunctionImporter => disable(importer) as FunctionImporter;
+
+const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
+  method: importer.method,
+  empty: (): boolean => importer.empty(),
+  use: (name: string): ts.Identifier => importer.use(name),
+  useLocal: (name: string): string => importer.useLocal(name),
+  hasLocal: (name: string): boolean => importer.hasLocal(name),
+  declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
+  declareUnions: (): ts.Statement[] => [],
+  increment: (): number => importer.increment(),
+  emplaceUnion: (
+    prefix: string,
+    name: string,
+    factory: () => ts.ArrowFunction,
+  ): string => importer.emplaceUnion(prefix, name, factory),
+  trace: (): void => importer.trace(),
+});
+
+type MethodOnly<T> = {
+  [P in keyof T]: T[P] extends Function
+    ? T[P]
+    : P extends "method"
+    ? T[P]
+    : never;
+};

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -1,77 +1,77 @@
-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): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(
-              HttpHeadersProgrammer.INPUT_TYPE,
-            ),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
-        ),
-        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")],
-              ),
-              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): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(
+              HttpHeadersProgrammer.INPUT_TYPE,
+            ),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          `typia.Resolved<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>`,
+        ),
+        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")],
+              ),
+              TypeFactory.keyword("any"),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -1,75 +1,75 @@
-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 { HttpQueryProgrammer } from "./HttpQueryProgrammer";
-
-export namespace HttpAssertQueryProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(HttpQueryProgrammer.INPUT_TYPE),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "decode",
-            HttpQueryProgrammer.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")],
-              ),
-              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 { HttpQueryProgrammer } from "./HttpQueryProgrammer";
+
+export namespace HttpAssertQueryProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(HttpQueryProgrammer.INPUT_TYPE),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          `typia.Resolved<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>`,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "decode",
+            HttpQueryProgrammer.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")],
+              ),
+              TypeFactory.keyword("any"),
+            ),
+          ),
+        ]),
+      );
+}