typia 7.2.1 → 7.3.0-dev.20241213

package/src/programmers/internal/decode_union_object.ts

@@ -1,116 +1,116 @@
-import ts from "typescript";
-
-import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-
-/**
- * @internal
- */
-export const decode_union_object = (props: {
-  checker: (next: {
-    input: ts.Expression;
-    object: MetadataObjectType;
-    explore: FeatureProgrammer.IExplore;
-  }) => ts.Expression;
-  decoder: (next: {
-    input: ts.Expression;
-    object: MetadataObjectType;
-    explore: FeatureProgrammer.IExplore;
-  }) => ts.Expression;
-  success: (exp: ts.Expression) => ts.Expression;
-  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
-  objects: MetadataObjectType[];
-  input: ts.Expression;
-  explore: FeatureProgrammer.IExplore;
-}): ts.CallExpression =>
-  ts.factory.createCallExpression(
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [],
-      undefined,
-      undefined,
-      iterate({
-        escaper: props.escaper,
-        input: props.input,
-        unions: props.objects.map((object) => ({
-          type: "object",
-          is: () =>
-            props.success(
-              props.checker({
-                input: props.input,
-                explore: props.explore,
-                object,
-              }),
-            ),
-          value: () =>
-            props.decoder({
-              input: props.input,
-              explore: props.explore,
-              object,
-            }),
-        })),
-        expected: `(${props.objects.map((t) => t.name).join(" | ")})`,
-      }),
-    ),
-    undefined,
-    undefined,
-  );
-
-/**
- * @internal
- */
-const iterate = (props: {
-  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
-  unions: IUnion[];
-  expected: string;
-  input: ts.Expression;
-}) => {
-  interface IBranch {
-    condition: null | ts.Expression;
-    value: ts.Expression;
-  }
-  const branches: IBranch[] = [];
-
-  for (const u of props.unions) {
-    const condition: ts.Expression = u.is();
-    if (condition.kind === ts.SyntaxKind.TrueKeyword) {
-      branches.push({
-        condition: null,
-        value: u.value(),
-      });
-      break;
-    }
-    branches.push({
-      condition,
-      value: u.value(),
-    });
-  }
-  if (branches.length === 0)
-    return ts.factory.createBlock([props.escaper(props)], true);
-  else if (branches.length === 1 && branches[0]!.condition === null)
-    return branches[0]!.value;
-
-  const statements: ts.Statement[] = branches.map((b) =>
-    b.condition !== null
-      ? ts.factory.createIfStatement(
-          b.condition,
-          ts.factory.createReturnStatement(b.value),
-          undefined,
-        )
-      : ts.factory.createReturnStatement(b.value),
-  );
-  if (branches.at(-1)!.condition !== null)
-    statements.push(props.escaper(props));
-  return ts.factory.createBlock(statements, true);
-};
-
-/**
- * @internal
- */
-interface IUnion {
-  type: string;
-  is: () => ts.Expression;
-  value: () => ts.Expression;
-}
+import ts from "typescript";
+
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+/**
+ * @internal
+ */
+export const decode_union_object = (props: {
+  checker: (next: {
+    input: ts.Expression;
+    object: MetadataObjectType;
+    explore: FeatureProgrammer.IExplore;
+  }) => ts.Expression;
+  decoder: (next: {
+    input: ts.Expression;
+    object: MetadataObjectType;
+    explore: FeatureProgrammer.IExplore;
+  }) => ts.Expression;
+  success: (exp: ts.Expression) => ts.Expression;
+  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
+  objects: MetadataObjectType[];
+  input: ts.Expression;
+  explore: FeatureProgrammer.IExplore;
+}): ts.CallExpression =>
+  ts.factory.createCallExpression(
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [],
+      undefined,
+      undefined,
+      iterate({
+        escaper: props.escaper,
+        input: props.input,
+        unions: props.objects.map((object) => ({
+          type: "object",
+          is: () =>
+            props.success(
+              props.checker({
+                input: props.input,
+                explore: props.explore,
+                object,
+              }),
+            ),
+          value: () =>
+            props.decoder({
+              input: props.input,
+              explore: props.explore,
+              object,
+            }),
+        })),
+        expected: `(${props.objects.map((t) => t.name).join(" | ")})`,
+      }),
+    ),
+    undefined,
+    undefined,
+  );
+
+/**
+ * @internal
+ */
+const iterate = (props: {
+  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
+  unions: IUnion[];
+  expected: string;
+  input: ts.Expression;
+}) => {
+  interface IBranch {
+    condition: null | ts.Expression;
+    value: ts.Expression;
+  }
+  const branches: IBranch[] = [];
+
+  for (const u of props.unions) {
+    const condition: ts.Expression = u.is();
+    if (condition.kind === ts.SyntaxKind.TrueKeyword) {
+      branches.push({
+        condition: null,
+        value: u.value(),
+      });
+      break;
+    }
+    branches.push({
+      condition,
+      value: u.value(),
+    });
+  }
+  if (branches.length === 0)
+    return ts.factory.createBlock([props.escaper(props)], true);
+  else if (branches.length === 1 && branches[0]!.condition === null)
+    return branches[0]!.value;
+
+  const statements: ts.Statement[] = branches.map((b) =>
+    b.condition !== null
+      ? ts.factory.createIfStatement(
+          b.condition,
+          ts.factory.createReturnStatement(b.value),
+          undefined,
+        )
+      : ts.factory.createReturnStatement(b.value),
+  );
+  if (branches.at(-1)!.condition !== null)
+    statements.push(props.escaper(props));
+  return ts.factory.createBlock(statements, true);
+};
+
+/**
+ * @internal
+ */
+interface IUnion {
+  type: string;
+  is: () => ts.Expression;
+  value: () => ts.Expression;
+}

package/src/programmers/internal/feature_object_entries.ts

@@ -1,61 +1,61 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-
-/**
- * @internal
- */
-export const feature_object_entries = <Output extends ts.ConciseBody>(props: {
-  config: Pick<FeatureProgrammer.IConfig<Output>, "decoder" | "path" | "trace">;
-  context: ITypiaContext;
-  object: MetadataObjectType;
-  input: ts.Expression;
-  from?: "object" | "top" | "array";
-}) =>
-  props.object.properties.map((next) => {
-    const sole: string | null = next.key.getSoleLiteral();
-    const propInput =
-      sole === null
-        ? ts.factory.createIdentifier("value")
-        : Escaper.variable(sole)
-          ? ts.factory.createPropertyAccessExpression(
-              props.input,
-              ts.factory.createIdentifier(sole),
-            )
-          : ts.factory.createElementAccessExpression(
-              props.input,
-              ts.factory.createStringLiteral(sole),
-            );
-    return {
-      input: propInput,
-      key: next.key,
-      meta: next.value,
-      expression: props.config.decoder({
-        input: propInput,
-        metadata: next.value,
-        explore: {
-          tracable: props.config.path || props.config.trace,
-          source: "function",
-          from: props.from ?? "object",
-          postfix: props.config.trace
-            ? sole !== null
-              ? IdentifierFactory.postfix(sole)
-              : (() => {
-                  props.context.importer.internal(ACCESSOR);
-                  return `${props.context.importer.getInternalText(ACCESSOR)}(key)`;
-                })()
-            : "",
-        },
-      }),
-    };
-  });
-
-const ACCESSOR = "accessExpressionAsString";
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+/**
+ * @internal
+ */
+export const feature_object_entries = <Output extends ts.ConciseBody>(props: {
+  config: Pick<FeatureProgrammer.IConfig<Output>, "decoder" | "path" | "trace">;
+  context: ITypiaContext;
+  object: MetadataObjectType;
+  input: ts.Expression;
+  from?: "object" | "top" | "array";
+}) =>
+  props.object.properties.map((next) => {
+    const sole: string | null = next.key.getSoleLiteral();
+    const propInput =
+      sole === null
+        ? ts.factory.createIdentifier("value")
+        : Escaper.variable(sole)
+          ? ts.factory.createPropertyAccessExpression(
+              props.input,
+              ts.factory.createIdentifier(sole),
+            )
+          : ts.factory.createElementAccessExpression(
+              props.input,
+              ts.factory.createStringLiteral(sole),
+            );
+    return {
+      input: propInput,
+      key: next.key,
+      meta: next.value,
+      expression: props.config.decoder({
+        input: propInput,
+        metadata: next.value,
+        explore: {
+          tracable: props.config.path || props.config.trace,
+          source: "function",
+          from: props.from ?? "object",
+          postfix: props.config.trace
+            ? sole !== null
+              ? IdentifierFactory.postfix(sole)
+              : (() => {
+                  props.context.importer.internal(ACCESSOR);
+                  return `${props.context.importer.getInternalText(ACCESSOR)}(key)`;
+                })()
+            : "",
+        },
+      }),
+    };
+  });
+
+const ACCESSOR = "accessExpressionAsString";

package/src/programmers/internal/json_schema_alias.ts

@@ -1,47 +1,47 @@
-import { OpenApi } from "@samchon/openapi";
-
-import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
-
-import { json_schema_description } from "./json_schema_description";
-import { json_schema_object } from "./json_schema_object";
-import { json_schema_station } from "./json_schema_station";
-import { json_schema_title } from "./json_schema_title";
-
-export const json_schema_alias = <BlockNever extends boolean>(props: {
-  blockNever: BlockNever;
-  components: OpenApi.IComponents;
-  alias: MetadataAlias;
-}): OpenApi.IJsonSchema.IReference[] => {
-  if (
-    props.alias.type.value.size() === 1 &&
-    props.alias.type.value.objects.length === 1
-  )
-    return json_schema_object({
-      components: props.components,
-      object: props.alias.type.value.objects[0]!,
-    }) as OpenApi.IJsonSchema.IReference[];
-
-  const $ref: string = `#/components/schemas/${props.alias.type.name}`;
-  if (props.components.schemas?.[props.alias.type.name] === undefined) {
-    // TEMPORARY ASSIGNMENT
-    props.components.schemas ??= {};
-    props.components.schemas[props.alias.type.name] = {};
-
-    // GENERATE SCHEMA
-    const schema: OpenApi.IJsonSchema | null = json_schema_station({
-      blockNever: props.blockNever,
-      components: props.components,
-      attribute: {
-        deprecated:
-          props.alias.type.jsDocTags.some((tag) => tag.name === "deprecated") ||
-          undefined,
-        title: json_schema_title(props.alias.type),
-        description: json_schema_description(props.alias.type),
-      },
-      metadata: props.alias.type.value,
-    });
-    if (schema !== null)
-      Object.assign(props.components.schemas[props.alias.type.name]!, schema);
-  }
-  return [{ $ref }];
-};
+import { OpenApi } from "@samchon/openapi";
+
+import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
+
+import { json_schema_description } from "./json_schema_description";
+import { json_schema_object } from "./json_schema_object";
+import { json_schema_station } from "./json_schema_station";
+import { json_schema_title } from "./json_schema_title";
+
+export const json_schema_alias = <BlockNever extends boolean>(props: {
+  blockNever: BlockNever;
+  components: OpenApi.IComponents;
+  alias: MetadataAlias;
+}): OpenApi.IJsonSchema.IReference[] => {
+  if (
+    props.alias.type.value.size() === 1 &&
+    props.alias.type.value.objects.length === 1
+  )
+    return json_schema_object({
+      components: props.components,
+      object: props.alias.type.value.objects[0]!,
+    }) as OpenApi.IJsonSchema.IReference[];
+
+  const $ref: string = `#/components/schemas/${props.alias.type.name}`;
+  if (props.components.schemas?.[props.alias.type.name] === undefined) {
+    // TEMPORARY ASSIGNMENT
+    props.components.schemas ??= {};
+    props.components.schemas[props.alias.type.name] = {};
+
+    // GENERATE SCHEMA
+    const schema: OpenApi.IJsonSchema | null = json_schema_station({
+      blockNever: props.blockNever,
+      components: props.components,
+      attribute: {
+        deprecated:
+          props.alias.type.jsDocTags.some((tag) => tag.name === "deprecated") ||
+          undefined,
+        title: json_schema_title(props.alias.type),
+        description: json_schema_description(props.alias.type),
+      },
+      metadata: props.alias.type.value,
+    });
+    if (schema !== null)
+      Object.assign(props.components.schemas[props.alias.type.name]!, schema);
+  }
+  return [{ $ref }];
+};

package/src/programmers/internal/json_schema_array.ts

@@ -1,45 +1,45 @@
-import { OpenApi } from "@samchon/openapi";
-
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { json_schema_plugin } from "./json_schema_plugin";
-import { json_schema_station } from "./json_schema_station";
-
-export const json_schema_array = (props: {
-  components: OpenApi.IComponents;
-  array: MetadataArray;
-}): Array<OpenApi.IJsonSchema.IArray | OpenApi.IJsonSchema.IReference> => {
-  const factory = (): OpenApi.IJsonSchema.IArray[] =>
-    json_schema_plugin({
-      schema: {
-        type: "array",
-        items: json_schema_station({
-          blockNever: false,
-          components: props.components,
-          metadata: props.array.type.value,
-          attribute: {},
-        }),
-      } satisfies OpenApi.IJsonSchema.IArray,
-      tags: props.array.tags,
-    });
-  if (props.array.type.recursive === true) {
-    const out = () => [
-      {
-        $ref: `#/components/schemas/${props.array.type.name}`,
-      },
-    ];
-    if (props.components.schemas?.[props.array.type.name] !== undefined)
-      return out();
-
-    props.components.schemas ??= {};
-    props.components.schemas[props.array.type.name] ??= {};
-
-    const oneOf: OpenApi.IJsonSchema.IArray[] = factory();
-    Object.assign(
-      props.components.schemas[props.array.type.name]!,
-      oneOf.length === 1 ? oneOf[0] : { oneOf },
-    );
-    return out();
-  }
-  return factory();
-};
+import { OpenApi } from "@samchon/openapi";
+
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { json_schema_plugin } from "./json_schema_plugin";
+import { json_schema_station } from "./json_schema_station";
+
+export const json_schema_array = (props: {
+  components: OpenApi.IComponents;
+  array: MetadataArray;
+}): Array<OpenApi.IJsonSchema.IArray | OpenApi.IJsonSchema.IReference> => {
+  const factory = (): OpenApi.IJsonSchema.IArray[] =>
+    json_schema_plugin({
+      schema: {
+        type: "array",
+        items: json_schema_station({
+          blockNever: false,
+          components: props.components,
+          metadata: props.array.type.value,
+          attribute: {},
+        }),
+      } satisfies OpenApi.IJsonSchema.IArray,
+      tags: props.array.tags,
+    });
+  if (props.array.type.recursive === true) {
+    const out = () => [
+      {
+        $ref: `#/components/schemas/${props.array.type.name}`,
+      },
+    ];
+    if (props.components.schemas?.[props.array.type.name] !== undefined)
+      return out();
+
+    props.components.schemas ??= {};
+    props.components.schemas[props.array.type.name] ??= {};
+
+    const oneOf: OpenApi.IJsonSchema.IArray[] = factory();
+    Object.assign(
+      props.components.schemas[props.array.type.name]!,
+      oneOf.length === 1 ? oneOf[0] : { oneOf },
+    );
+    return out();
+  }
+  return factory();
+};

package/src/programmers/internal/json_schema_bigint.ts

@@ -1,15 +1,15 @@
-import { OpenApi } from "@samchon/openapi";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { json_schema_plugin } from "./json_schema_plugin";
-
-export const json_schema_bigint = (
-  atomic: MetadataAtomic,
-): OpenApi.IJsonSchema.IInteger[] =>
-  json_schema_plugin({
-    schema: {
-      type: "integer",
-    } satisfies OpenApi.IJsonSchema.IInteger,
-    tags: atomic.tags,
-  });
+import { OpenApi } from "@samchon/openapi";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { json_schema_plugin } from "./json_schema_plugin";
+
+export const json_schema_bigint = (
+  atomic: MetadataAtomic,
+): OpenApi.IJsonSchema.IInteger[] =>
+  json_schema_plugin({
+    schema: {
+      type: "integer",
+    } satisfies OpenApi.IJsonSchema.IInteger,
+    tags: atomic.tags,
+  });

package/src/programmers/internal/json_schema_boolean.ts

@@ -1,15 +1,15 @@
-import { OpenApi } from "@samchon/openapi";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { json_schema_plugin } from "./json_schema_plugin";
-
-export const json_schema_boolean = (
-  atomic: MetadataAtomic,
-): OpenApi.IJsonSchema.IBoolean[] =>
-  json_schema_plugin({
-    schema: {
-      type: "boolean",
-    } satisfies OpenApi.IJsonSchema.IBoolean,
-    tags: atomic.tags,
-  });
+import { OpenApi } from "@samchon/openapi";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { json_schema_plugin } from "./json_schema_plugin";
+
+export const json_schema_boolean = (
+  atomic: MetadataAtomic,
+): OpenApi.IJsonSchema.IBoolean[] =>
+  json_schema_plugin({
+    schema: {
+      type: "boolean",
+    } satisfies OpenApi.IJsonSchema.IBoolean,
+    tags: atomic.tags,
+  });

package/src/programmers/internal/json_schema_constant.ts

@@ -1,26 +1,26 @@
-import { OpenApi } from "@samchon/openapi";
-
-import { MetadataConstant } from "../../schemas/metadata/MetadataConstant";
-
-import { json_schema_description } from "./json_schema_description";
-import { json_schema_plugin } from "./json_schema_plugin";
-import { json_schema_title } from "./json_schema_title";
-
-export const json_schema_constant = (
-  constant: MetadataConstant,
-): OpenApi.IJsonSchema.IConstant[] =>
-  constant.values
-    .map((value) =>
-      json_schema_plugin({
-        schema: {
-          const:
-            typeof value.value === "bigint"
-              ? Number(value.value)
-              : (value.value as boolean | number | string),
-          title: json_schema_title(value),
-          description: json_schema_description(value),
-        } satisfies OpenApi.IJsonSchema.IConstant,
-        tags: value.tags ?? [],
-      }),
-    )
-    .flat();
+import { OpenApi } from "@samchon/openapi";
+
+import { MetadataConstant } from "../../schemas/metadata/MetadataConstant";
+
+import { json_schema_description } from "./json_schema_description";
+import { json_schema_plugin } from "./json_schema_plugin";
+import { json_schema_title } from "./json_schema_title";
+
+export const json_schema_constant = (
+  constant: MetadataConstant,
+): OpenApi.IJsonSchema.IConstant[] =>
+  constant.values
+    .map((value) =>
+      json_schema_plugin({
+        schema: {
+          const:
+            typeof value.value === "bigint"
+              ? Number(value.value)
+              : (value.value as boolean | number | string),
+          title: json_schema_title(value),
+          description: json_schema_description(value),
+        } satisfies OpenApi.IJsonSchema.IConstant,
+        tags: value.tags ?? [],
+      }),
+    )
+    .flat();