typia 6.10.0 → 6.10.1-dev.20240919

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,33 +1,33 @@
-import ts from "typescript";
-
-import { FunctionImporter } from "./FunctionImporter";
-
-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),
-  emplaceVariable: (key, value) => importer.emplaceVariable(key, value),
-  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 "./FunctionImporter";
+
+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),
+  emplaceVariable: (key, value) => importer.emplaceVariable(key, value),
+  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/HttpParameterProgrammer.ts

@@ -1,97 +1,97 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProject } from "../../transformers/IProject";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
-
-export namespace HttpParameterProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction => {
-      const result = MetadataFactory.analyze(
-        project.checker,
-        project.context,
-      )({
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate,
-      })(new MetadataCollection())(type);
-      if (result.success === false)
-        throw TransformerError.from(modulo.getText())(result.errors);
-
-      const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const block: ts.Statement[] = [
-        StatementFactory.constant(
-          "assert",
-          AssertProgrammer.write({
-            ...project,
-            options: {
-              numeric: true,
-            },
-          })(modulo)(false)(type, name),
-        ),
-        StatementFactory.constant(
-          "value",
-          ts.factory.createCallExpression(importer.use(atomic), undefined, [
-            ts.factory.createIdentifier("input"),
-          ]),
-        ),
-        ts.factory.createReturnStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("assert"),
-            undefined,
-            [ts.factory.createIdentifier("value")],
-          ),
-        ),
-      ];
-
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode("string"),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode(
-          name ?? TypeFactory.getFullName(project.checker)(type),
-        ),
-        undefined,
-        ts.factory.createBlock([...importer.declare(modulo), ...block], true),
-      );
-    };
-
-  export const validate = (meta: Metadata): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (meta.any) insert("do not allow any type");
-    if (meta.isRequired() === false) insert("do not allow undefindable type");
-
-    const atomics = HttpMetadataUtil.atomics(meta);
-    const expected: number =
-      meta.atomics.length +
-      meta.templates.length +
-      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-    if (meta.size() !== expected || atomics.size === 0)
-      insert("only atomic or constant types are allowed");
-    if (atomics.size > 1) insert("do not allow union type");
-
-    return errors;
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
+
+export namespace HttpParameterProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction => {
+      const result = MetadataFactory.analyze(
+        project.checker,
+        project.context,
+      )({
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      })(new MetadataCollection())(type);
+      if (result.success === false)
+        throw TransformerError.from(modulo.getText())(result.errors);
+
+      const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const block: ts.Statement[] = [
+        StatementFactory.constant(
+          "assert",
+          AssertProgrammer.write({
+            ...project,
+            options: {
+              numeric: true,
+            },
+          })(modulo)(false)(type, name),
+        ),
+        StatementFactory.constant(
+          "value",
+          ts.factory.createCallExpression(importer.use(atomic), undefined, [
+            ts.factory.createIdentifier("input"),
+          ]),
+        ),
+        ts.factory.createReturnStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("assert"),
+            undefined,
+            [ts.factory.createIdentifier("value")],
+          ),
+        ),
+      ];
+
+      return ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode("string"),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          name ?? TypeFactory.getFullName(project.checker)(type),
+        ),
+        undefined,
+        ts.factory.createBlock([...importer.declare(modulo), ...block], true),
+      );
+    };
+
+  export const validate = (meta: Metadata): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (meta.any) insert("do not allow any type");
+    if (meta.isRequired() === false) insert("do not allow undefindable type");
+
+    const atomics = HttpMetadataUtil.atomics(meta);
+    const expected: number =
+      meta.atomics.length +
+      meta.templates.length +
+      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+    if (meta.size() !== expected || atomics.size === 0)
+      insert("only atomic or constant types are allowed");
+    if (atomics.size > 1) insert("do not allow union type");
+
+    return errors;
+  };
+}

package/src/programmers/internal/application_array.ts

@@ -1,61 +1,61 @@
-import { OpenApi, OpenApiV3 } from "@samchon/openapi";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { application_plugin } from "./application_plugin";
-
-/**
- * @internal
- */
-export const application_array =
-  <Version extends "3.0" | "3.1">(
-    generator: (value: Metadata) => Schema<Version>,
-  ) =>
-  (
-    components: Version extends "3.0"
-      ? OpenApiV3.IComponents
-      : OpenApi.IComponents,
-  ) =>
-  (
-    array: MetadataArray,
-  ): Array<ArraySchema<Version> | OpenApiV3.IJsonSchema.IReference> => {
-    const factory = (): ArraySchema<Version>[] =>
-      application_plugin<ArraySchema<Version>>(
-        {
-          type: "array",
-          items: generator(array.type.value),
-        } as ArraySchema<Version>,
-        array.tags,
-      );
-    if (array.type.recursive === true) {
-      const out = () => [{ $ref }];
-      const $ref: string = `#/components/schemas/${array.type.name}`;
-      if (components.schemas?.[$ref] !== undefined) return out();
-
-      components.schemas ??= {};
-      components.schemas[$ref] ??= {};
-
-      const oneOf: ArraySchema<Version>[] = factory();
-      Object.assign(
-        components.schemas[$ref]!,
-        oneOf.length === 1 ? oneOf[0] : { oneOf },
-      );
-      return out();
-    }
-    return factory();
-  };
-
-/**
- * @internal
- */
-type ArraySchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
-  ? OpenApiV3.IJsonSchema.IArray
-  : OpenApi.IJsonSchema.IArray;
-
-/**
- * @internal
- */
-type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
-  ? OpenApiV3.IJsonSchema
-  : OpenApi.IJsonSchema;
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { application_plugin } from "./application_plugin";
+
+/**
+ * @internal
+ */
+export const application_array =
+  <Version extends "3.0" | "3.1">(
+    generator: (value: Metadata) => Schema<Version>,
+  ) =>
+  (
+    components: Version extends "3.0"
+      ? OpenApiV3.IComponents
+      : OpenApi.IComponents,
+  ) =>
+  (
+    array: MetadataArray,
+  ): Array<ArraySchema<Version> | OpenApiV3.IJsonSchema.IReference> => {
+    const factory = (): ArraySchema<Version>[] =>
+      application_plugin<ArraySchema<Version>>(
+        {
+          type: "array",
+          items: generator(array.type.value),
+        } as ArraySchema<Version>,
+        array.tags,
+      );
+    if (array.type.recursive === true) {
+      const out = () => [{ $ref }];
+      const $ref: string = `#/components/schemas/${array.type.name}`;
+      if (components.schemas?.[$ref] !== undefined) return out();
+
+      components.schemas ??= {};
+      components.schemas[$ref] ??= {};
+
+      const oneOf: ArraySchema<Version>[] = factory();
+      Object.assign(
+        components.schemas[$ref]!,
+        oneOf.length === 1 ? oneOf[0] : { oneOf },
+      );
+      return out();
+    }
+    return factory();
+  };
+
+/**
+ * @internal
+ */
+type ArraySchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IArray
+  : OpenApi.IJsonSchema.IArray;
+
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema
+  : OpenApi.IJsonSchema;

package/src/programmers/internal/application_boolean.ts

@@ -1,25 +1,25 @@
-import { OpenApi, OpenApiV3 } from "@samchon/openapi";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { application_plugin } from "./application_plugin";
-
-/**
- * @internal
- */
-export const application_boolean = <Version extends "3.0" | "3.1">(
-  atomic: MetadataAtomic,
-): Schema<Version>[] =>
-  application_plugin(
-    {
-      type: "boolean",
-    } satisfies Schema<Version>,
-    atomic.tags,
-  );
-
-/**
- * @internal
- */
-type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
-  ? OpenApiV3.IJsonSchema.IBoolean
-  : OpenApi.IJsonSchema.IBoolean;
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { application_plugin } from "./application_plugin";
+
+/**
+ * @internal
+ */
+export const application_boolean = <Version extends "3.0" | "3.1">(
+  atomic: MetadataAtomic,
+): Schema<Version>[] =>
+  application_plugin(
+    {
+      type: "boolean",
+    } satisfies Schema<Version>,
+    atomic.tags,
+  );
+
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IBoolean
+  : OpenApi.IJsonSchema.IBoolean;

package/src/programmers/internal/application_description.ts

@@ -1,12 +1,12 @@
-import { IJsDocTagInfo } from "../../module";
-
-export const application_description = (props: {
-  description?: string | null | undefined;
-  jsDocTags?: IJsDocTagInfo[];
-}): string | undefined =>
-  props.jsDocTags
-    ?.find((tag) => tag.name === "description")
-    ?.text?.[0]?.text?.split("\r\n")
-    .join("\n") ??
-  props.description ??
-  undefined;
+import { IJsDocTagInfo } from "../../module";
+
+export const application_description = (props: {
+  description?: string | null | undefined;
+  jsDocTags?: IJsDocTagInfo[];
+}): string | undefined =>
+  props.jsDocTags
+    ?.find((tag) => tag.name === "description")
+    ?.text?.[0]?.text?.split("\r\n")
+    .join("\n") ??
+  props.description ??
+  undefined;

package/src/programmers/internal/application_number.ts

@@ -1,25 +1,25 @@
-import { OpenApi, OpenApiV3 } from "@samchon/openapi";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { application_plugin } from "./application_plugin";
-
-/**
- * @internal
- */
-export const application_number = <Version extends "3.0" | "3.1">(
-  atomic: MetadataAtomic,
-): Schema<Version>[] =>
-  application_plugin(
-    {
-      type: "number",
-    } satisfies Schema<Version>,
-    atomic.tags,
-  );
-
-/**
- * @internal
- */
-type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
-  ? OpenApiV3.IJsonSchema.IInteger | OpenApiV3.IJsonSchema.INumber
-  : OpenApi.IJsonSchema.IInteger | OpenApi.IJsonSchema.INumber;
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { application_plugin } from "./application_plugin";
+
+/**
+ * @internal
+ */
+export const application_number = <Version extends "3.0" | "3.1">(
+  atomic: MetadataAtomic,
+): Schema<Version>[] =>
+  application_plugin(
+    {
+      type: "number",
+    } satisfies Schema<Version>,
+    atomic.tags,
+  );
+
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IInteger | OpenApiV3.IJsonSchema.INumber
+  : OpenApi.IJsonSchema.IInteger | OpenApi.IJsonSchema.INumber;