typia 9.7.1 → 10.0.0-dev.20251107

package/src/programmers/internal/decode_union_object.ts

@@ -1,116 +1,110 @@
-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,59 @@
-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_escaped.ts

@@ -1,82 +1,78 @@
-import { OpenApi, OpenApiTypeChecker } from "@samchon/openapi";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
-
-import { json_schema_station } from "./json_schema_station";
-
-/**
- * @internal
- */
-export const json_schema_escaped = (props: {
-  components: OpenApi.IComponents;
-  escaped: MetadataEscaped;
-}): OpenApi.IJsonSchema[] => {
-  const output: OpenApi.IJsonSchema | null = json_schema_station({
-    blockNever: false,
-    components: props.components,
-    metadata: props.escaped.returns,
-    attribute: {},
-  });
-  if (output === null) return [];
-
-  if (
-    is_date({
-      visited: new Set(),
-      metadata: props.escaped.original,
-    })
-  ) {
-    const string: OpenApi.IJsonSchema.IString | undefined =
-      OpenApiTypeChecker.isString(output)
-        ? output
-        : OpenApiTypeChecker.isOneOf(output)
-          ? (output.oneOf.find(
-              OpenApiTypeChecker.isString,
-            ) as OpenApi.IJsonSchema.IString)
-          : undefined;
-    if (
-      string !== undefined &&
-      string.format !== "date" &&
-      string.format !== "date-time"
-    )
-      string.format = "date-time";
-  }
-  return OpenApiTypeChecker.isOneOf(output)
-    ? (output.oneOf as OpenApi.IJsonSchema[])
-    : [output];
-};
-
-/**
- * @internal
- */
-const is_date = (props: {
-  visited: Set<Metadata>;
-  metadata: Metadata;
-}): boolean => {
-  if (props.visited.has(props.metadata)) return false;
-  props.visited.add(props.metadata);
-
-  return (
-    props.metadata.natives.some((native) => native.name === "Date") ||
-    props.metadata.arrays.some((array) =>
-      is_date({
-        visited: props.visited,
-        metadata: array.type.value,
-      }),
-    ) ||
-    props.metadata.tuples.some((tuple) =>
-      tuple.type.elements.some((e) =>
-        is_date({
-          visited: props.visited,
-          metadata: e,
-        }),
-      ),
-    ) ||
-    props.metadata.aliases.some((alias) =>
-      is_date({
-        visited: props.visited,
-        metadata: alias.type.value,
-      }),
-    )
-  );
-};
+import { OpenApi, OpenApiTypeChecker } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
+
+import { json_schema_station } from "./json_schema_station";
+
+/** @internal */
+export const json_schema_escaped = (props: {
+  components: OpenApi.IComponents;
+  escaped: MetadataEscaped;
+}): OpenApi.IJsonSchema[] => {
+  const output: OpenApi.IJsonSchema | null = json_schema_station({
+    blockNever: false,
+    components: props.components,
+    metadata: props.escaped.returns,
+    attribute: {},
+  });
+  if (output === null) return [];
+
+  if (
+    is_date({
+      visited: new Set(),
+      metadata: props.escaped.original,
+    })
+  ) {
+    const string: OpenApi.IJsonSchema.IString | undefined =
+      OpenApiTypeChecker.isString(output)
+        ? output
+        : OpenApiTypeChecker.isOneOf(output)
+          ? (output.oneOf.find(
+              OpenApiTypeChecker.isString,
+            ) as OpenApi.IJsonSchema.IString)
+          : undefined;
+    if (
+      string !== undefined &&
+      string.format !== "date" &&
+      string.format !== "date-time"
+    )
+      string.format = "date-time";
+  }
+  return OpenApiTypeChecker.isOneOf(output)
+    ? (output.oneOf as OpenApi.IJsonSchema[])
+    : [output];
+};
+
+/** @internal */
+const is_date = (props: {
+  visited: Set<Metadata>;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
+
+  return (
+    props.metadata.natives.some((native) => native.name === "Date") ||
+    props.metadata.arrays.some((array) =>
+      is_date({
+        visited: props.visited,
+        metadata: array.type.value,
+      }),
+    ) ||
+    props.metadata.tuples.some((tuple) =>
+      tuple.type.elements.some((e) =>
+        is_date({
+          visited: props.visited,
+          metadata: e,
+        }),
+      ),
+    ) ||
+    props.metadata.aliases.some((alias) =>
+      is_date({
+        visited: props.visited,
+        metadata: alias.type.value,
+      }),
+    )
+  );
+};