@typia/core 12.0.0-dev.20260225

package/src/programmers/helpers/RandomJoiner.ts

@@ -0,0 +1,168 @@
+import { OpenApi } from "@typia/interface";
+import { NamingConvention } from "@typia/utils";
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
+
+export namespace RandomJoiner {
+  export type Decoder = (metadata: MetadataSchema) => ts.Expression;
+
+  export const array = (props: {
+    decode: Decoder;
+    recursive: boolean;
+    expression: ts.Expression;
+    array: MetadataArrayType;
+    schema: Omit<OpenApi.IJsonSchema.IArray, "items"> | undefined;
+  }): ts.Expression => {
+    const call: ts.Expression = ts.factory.createCallExpression(
+      props.expression,
+      undefined,
+      [
+        ts.factory.createObjectLiteralExpression(
+          [
+            ...(props.schema
+              ? Object.entries(props.schema)
+                  .filter(([key]) => key !== "items")
+                  .map(([key, value]) =>
+                    ts.factory.createPropertyAssignment(
+                      IdentifierFactory.identifier(key),
+                      LiteralFactory.write(value),
+                    ),
+                  )
+              : []),
+            ...(props.schema
+              ? []
+              : [
+                  ts.factory.createSpreadAssignment(
+                    ts.factory.createIdentifier("_schema"),
+                  ),
+                ]),
+            ts.factory.createPropertyAssignment(
+              "element",
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                undefined,
+                props.decode(props.array.value),
+              ),
+            ),
+          ],
+          true,
+        ),
+      ],
+    );
+    if (props.recursive === false) return call;
+    return ts.factory.createConditionalExpression(
+      ts.factory.createGreaterThanEquals(
+        ExpressionFactory.number(5),
+        ts.factory.createIdentifier("_depth"),
+      ),
+      undefined,
+      call,
+      undefined,
+      ts.factory.createArrayLiteralExpression([]),
+    );
+  };
+
+  export const tuple = (props: {
+    decode: Decoder;
+    elements: MetadataSchema[];
+  }): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(
+      props.elements.map((elem) => props.decode(elem.rest ?? elem)),
+      true,
+    );
+
+  export const object = (props: {
+    decode: Decoder;
+    object: MetadataObjectType;
+  }): ts.ConciseBody => {
+    if (props.object.properties.length === 0) return LiteralFactory.write({});
+
+    // LIST UP PROPERTIES
+    const regular = props.object.properties.filter((p) =>
+      p.key.isSoleLiteral(),
+    );
+    const dynamic = props.object.properties.filter(
+      (p) => !p.key.isSoleLiteral(),
+    );
+
+    return ts.factory.createObjectLiteralExpression(
+      [
+        ...regular.map((p) => {
+          const str: string = p.key.getSoleLiteral()!;
+          return ts.factory.createPropertyAssignment(
+            NamingConvention.variable(str)
+              ? str
+              : ts.factory.createStringLiteral(str),
+            props.decode(p.value),
+          );
+        }),
+        ...dynamic.map((property) =>
+          ts.factory.createSpreadAssignment(
+            dynamicProperty({
+              decode: props.decode,
+              property: property,
+            }),
+          ),
+        ),
+      ],
+      true,
+    );
+  };
+
+  const dynamicProperty = (props: {
+    decode: Decoder;
+    property: MetadataProperty;
+  }) => {
+    const tuple: MetadataTuple = MetadataTuple.create({
+      type: MetadataTupleType.create({
+        name: `[${props.property.key.getName()}, ${props.property.value.getName()}]`,
+        elements: [props.property.key, props.property.value],
+        index: null,
+        recursive: false,
+        nullables: [false],
+      }),
+      tags: [],
+    });
+    const array: MetadataArray = MetadataArray.create({
+      type: MetadataArrayType.create({
+        name: `Array<[${props.property.key.getName()}, ${props.property.value.getName()}]>`,
+        value: MetadataSchema.create({
+          ...MetadataSchema.initialize(),
+          tuples: [tuple],
+        }),
+        nullables: [false],
+        recursive: false,
+        index: null,
+      }),
+      tags: [[]],
+    });
+    return ts.factory.createCallExpression(
+      IdentifierFactory.access(
+        ts.factory.createIdentifier("Object"),
+        "fromEntries",
+      ),
+      undefined,
+      [
+        props.decode(
+          MetadataSchema.create({
+            ...MetadataSchema.initialize(),
+            arrays: [array],
+          }),
+        ),
+      ],
+    );
+  };
+}

package/src/programmers/helpers/StringifyJoinder.ts

@@ -0,0 +1,113 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+import { stringify_dynamic_properties } from "../iterate/stringify_dynamic_properties";
+import { stringify_regular_properties } from "../iterate/stringify_regular_properties";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace StringifyJoiner {
+  export const object = (props: {
+    context: ITypiaContext;
+    entries: IExpressionEntry<ts.Expression>[];
+  }): ts.Expression => {
+    // CHECK AND SORT ENTRIES
+    if (props.entries.length === 0) return ts.factory.createStringLiteral("{}");
+
+    // PROPERTIES
+    const regular: IExpressionEntry<ts.Expression>[] = props.entries.filter(
+      (entry) => entry.key.isSoleLiteral(),
+    );
+    const dynamic: IExpressionEntry<ts.Expression>[] = props.entries.filter(
+      (entry) => !entry.key.isSoleLiteral(),
+    );
+    const expressions: ts.Expression[] = [
+      ...stringify_regular_properties({
+        regular,
+        dynamic,
+      }),
+      ...(dynamic.length
+        ? [
+            stringify_dynamic_properties(
+              dynamic,
+              regular.map((r) => r.key.getSoleLiteral()!),
+            ),
+          ]
+        : []),
+    ];
+
+    // POP LAST COMMA, IF REQUIRED
+    const filtered: ts.Expression[] =
+      (regular.length &&
+        regular[regular.length - 1]!.meta.isRequired() &&
+        dynamic.length === 0) ||
+      (regular.length === 0 && dynamic.length)
+        ? expressions
+        : [
+            ts.factory.createCallExpression(
+              props.context.importer.internal("jsonStringifyTail"),
+              undefined,
+              [TemplateFactory.generate(expressions)],
+            ),
+          ];
+
+    // RETURNS WITH OBJECT BRACKET
+    return TemplateFactory.generate([
+      ts.factory.createStringLiteral(`{`),
+      ...filtered,
+      ts.factory.createStringLiteral(`}`),
+    ]);
+  };
+
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.ArrowFunction;
+  }): ts.Expression =>
+    TemplateFactory.generate([
+      ts.factory.createStringLiteral(`[`),
+      ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(props.input, "map"),
+            undefined,
+            [props.arrow],
+          ),
+          ts.factory.createIdentifier("join"),
+        ),
+        undefined,
+        [ts.factory.createStringLiteral(`,`)],
+      ),
+      ts.factory.createStringLiteral(`]`),
+    ]);
+
+  export const tuple = (props: {
+    elements: ts.Expression[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
+    if (props.elements.length === 0)
+      return ts.factory.createStringLiteral("[]");
+    if (
+      props.rest === null &&
+      props.elements.every((child) => ts.isStringLiteral(child))
+    )
+      return ts.factory.createStringLiteral(
+        "[" +
+          props.elements
+            .map((child) => (child as ts.StringLiteral).text)
+            .join(",") +
+          "]",
+      );
+
+    const expressions: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
+    props.elements.forEach((child, i) => {
+      expressions.push(child);
+      if (i !== props.elements.length - 1)
+        expressions.push(ts.factory.createStringLiteral(`,`));
+    });
+    if (props.rest !== null) expressions.push(props.rest);
+
+    expressions.push(ts.factory.createStringLiteral(`]`));
+    return TemplateFactory.generate(expressions);
+  };
+}

package/src/programmers/helpers/StringifyPredicator.ts

@@ -0,0 +1,13 @@
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+
+export namespace StringifyPredicator {
+  export const require_escape = (value: string): boolean =>
+    value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
+
+  export const undefindable = (metadata: MetadataSchema): boolean =>
+    metadata.isRequired() === false ||
+    (metadata.escaped !== null &&
+      metadata.escaped.returns.isRequired() === false);
+
+  const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
+}

package/src/programmers/helpers/UnionExplorer.ts

@@ -0,0 +1,377 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+import { MetadataSet } from "../../schemas/metadata/MetadataSet";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
+import { FeatureProgrammer } from "../internal/FeatureProgrammer";
+import { check_union_array_like } from "../iterate/check_union_array_like";
+import { UnionPredicator } from "./UnionPredicator";
+
+export namespace UnionExplorer {
+  export interface Decoder<T> {
+    (props: {
+      input: ts.Expression;
+      definition: T;
+      explore: FeatureProgrammer.IExplore;
+    }): ts.Expression;
+  }
+  export type ObjectCombiner = Decoder<MetadataObjectType[]>;
+
+  /* -----------------------------------------------------------
+        OBJECT
+    ----------------------------------------------------------- */
+  export const object = (props: {
+    config: FeatureProgrammer.IConfig;
+    level?: number;
+    objects: MetadataObjectType[];
+    input: ts.Expression;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    // BREAKER
+    if (props.objects.length === 1)
+      return props.config.objector.decoder({
+        input: props.input,
+        object: props.objects[0]!,
+        explore: props.explore,
+      });
+
+    const expected: string = `(${props.objects.map((t) => t.name).join(" | ")})`;
+
+    // POSSIBLE TO SPECIALIZE?
+    const specList = UnionPredicator.object(props.objects);
+    if (specList.length === 0) {
+      const condition: ts.Expression = props.config.objector.unionizer({
+        objects: props.objects,
+        input: props.input,
+        explore: {
+          ...props.explore,
+          tracable: false,
+        },
+      });
+      return props.config.objector.full
+        ? props.config.objector.full({
+            condition,
+            expected,
+            explore: props.explore,
+            input: props.input,
+          })
+        : condition;
+    }
+    const remained: MetadataObjectType[] = props.objects.filter(
+      (t) => specList.find((s) => s.object === t) === undefined,
+    );
+
+    // DO SPECIALIZE
+    const condition: ts.IfStatement = specList
+      .filter((spec) => spec.property.key.getSoleLiteral() !== null)
+      .map((spec, i, array) => {
+        const key: string = spec.property.key.getSoleLiteral()!;
+        const accessor: ts.Expression = IdentifierFactory.access(
+          props.input,
+          key,
+        );
+        const pred: ts.Expression = spec.neighbor
+          ? props.config.objector.checker({
+              input: accessor,
+              metadata: spec.property.value,
+              explore: {
+                ...props.explore,
+                tracable: false,
+                postfix: IdentifierFactory.postfix(key),
+              },
+            })
+          : (props.config.objector.required || ((exp) => exp))(
+              ExpressionFactory.isRequired(accessor),
+            );
+        return ts.factory.createIfStatement(
+          (props.config.objector.is || ((exp) => exp))(pred),
+          ts.factory.createReturnStatement(
+            props.config.objector.decoder({
+              object: spec.object,
+              input: props.input,
+              explore: props.explore,
+            }),
+          ),
+          i === array.length - 1
+            ? remained.length
+              ? ts.factory.createReturnStatement(
+                  object({
+                    config: props.config,
+                    level: (props.level ?? 0) + 1,
+                    input: props.input,
+                    objects: remained,
+                    explore: props.explore,
+                  }),
+                )
+              : props.config.objector.failure({
+                  input: props.input,
+                  explore: props.explore,
+                  expected,
+                })
+            : undefined,
+        );
+      })
+      .reverse()
+      .reduce((a, b) =>
+        ts.factory.createIfStatement(b.expression, b.thenStatement, a),
+      );
+
+    // RETURNS WITH CONDITIONS
+    return ts.factory.createCallExpression(
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        undefined,
+        ts.factory.createBlock([condition], true),
+      ),
+      undefined,
+      undefined,
+    );
+  };
+
+  /* -----------------------------------------------------------
+        ARRAY LIKE
+    ----------------------------------------------------------- */
+  export const tuple = (props: {
+    config: check_union_array_like.IConfig<MetadataTuple, MetadataTuple>;
+    parameters: ts.ParameterDeclaration[];
+    input: ts.Expression;
+    tuples: MetadataTuple[];
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    check_union_array_like<MetadataTuple, MetadataTuple, MetadataTuple>({
+      config: props.config,
+      accessor: {
+        transform: (x) => x,
+        element: (x) => x,
+        size: null!,
+        front: (input) => input,
+        array: (input) => input,
+        name: (t) => t.type.name,
+      },
+      parameters: props.parameters,
+      input: props.input,
+      definitions: props.tuples,
+      explore: props.explore,
+    });
+  export namespace tuple {
+    export type IConfig = check_union_array_like.IConfig<
+      MetadataTuple,
+      MetadataTuple
+    >;
+  }
+
+  export const array = (props: {
+    config: array.IConfig;
+    parameters: ts.ParameterDeclaration[];
+    input: ts.Expression;
+    arrays: MetadataArray[];
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    check_union_array_like<MetadataArray, MetadataArray, MetadataSchema>({
+      config: props.config,
+      accessor: {
+        transform: (x) => x,
+        element: (x) => x.type.value,
+        size: (input) => IdentifierFactory.access(input, "length"),
+        front: (input) => ts.factory.createElementAccessExpression(input, 0),
+        array: (input) => input,
+        name: (t) => t.type.name,
+      },
+      parameters: props.parameters,
+      input: props.input,
+      definitions: props.arrays,
+      explore: props.explore,
+    });
+  export namespace array {
+    export type IConfig = check_union_array_like.IConfig<
+      MetadataArray,
+      MetadataSchema
+    >;
+  }
+
+  export const array_or_tuple = (props: {
+    config: array_or_tuple.IConfig;
+    parameters: ts.ParameterDeclaration[];
+    input: ts.Expression;
+    definitions: (MetadataArray | MetadataTuple)[];
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    check_union_array_like<
+      MetadataArray | MetadataTuple,
+      MetadataArray | MetadataTuple,
+      MetadataSchema | MetadataTuple
+    >({
+      config: props.config,
+      accessor: {
+        transform: (x) => x,
+        element: (x) => (x instanceof MetadataArray ? x.type.value : x),
+        size: (input) => IdentifierFactory.access(input, "length"),
+        front: (input) => ts.factory.createElementAccessExpression(input, 0),
+        array: (input) => input,
+        name: (m) => m.type.name,
+      },
+      parameters: props.parameters,
+      input: props.input,
+      definitions: props.definitions,
+      explore: props.explore,
+    });
+  export namespace array_or_tuple {
+    export type IConfig = check_union_array_like.IConfig<
+      MetadataArray | MetadataTuple,
+      MetadataSchema | MetadataTuple
+    >;
+  }
+
+  export const set = (props: {
+    config: set.IConfig;
+    parameters: ts.ParameterDeclaration[];
+    input: ts.Expression;
+    sets: MetadataSet[];
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    check_union_array_like<MetadataSchema, MetadataArray, MetadataSchema>({
+      config: props.config,
+      accessor: {
+        transform: (value: MetadataSchema) =>
+          MetadataArray.create({
+            tags: [],
+            type: MetadataArrayType.create({
+              name: `Set<${value.getName()}>`,
+              index: null,
+              recursive: false,
+              nullables: [],
+              value,
+            }),
+          }),
+        element: (array) => array.type.value,
+        size: (input) => IdentifierFactory.access(input, "size"),
+        front: (input) =>
+          IdentifierFactory.access(
+            ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                  IdentifierFactory.access(input, "values"),
+                  undefined,
+                  undefined,
+                ),
+                "next",
+              ),
+              undefined,
+              undefined,
+            ),
+            "value",
+          ),
+        array: (input) =>
+          ts.factory.createArrayLiteralExpression(
+            [ts.factory.createSpreadElement(input)],
+            false,
+          ),
+        name: (_m, e) => `Set<${e.getName()}>`,
+      },
+      parameters: props.parameters,
+      input: props.input,
+      definitions: props.sets.map((s) => s.value),
+      explore: props.explore,
+    });
+  export namespace set {
+    export type IConfig = check_union_array_like.IConfig<
+      MetadataArray,
+      MetadataSchema
+    >;
+  }
+
+  export const map = (props: {
+    config: map.IConfig;
+    parameters: ts.ParameterDeclaration[];
+    input: ts.Expression;
+    maps: MetadataMap[];
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    check_union_array_like<
+      MetadataMap,
+      MetadataArray,
+      [MetadataSchema, MetadataSchema]
+    >({
+      config: props.config,
+      accessor: {
+        element: (array) =>
+          array.type.value.tuples[0]!.type.elements as [
+            MetadataSchema,
+            MetadataSchema,
+          ],
+        size: (input) => IdentifierFactory.access(input, "size"),
+        front: (input) =>
+          IdentifierFactory.access(
+            ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                  IdentifierFactory.access(input, "entries"),
+                  undefined,
+                  undefined,
+                ),
+                "next",
+              ),
+              undefined,
+              undefined,
+            ),
+            "value",
+          ),
+        array: (input) =>
+          ts.factory.createArrayLiteralExpression(
+            [ts.factory.createSpreadElement(input)],
+            false,
+          ),
+        name: (_m, [k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
+        transform: (m: MetadataMap) =>
+          MetadataArray.create({
+            tags: [],
+            type: MetadataArrayType.create({
+              name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+              index: null,
+              recursive: false,
+              nullables: [],
+              value: MetadataSchema.create({
+                ...MetadataSchema.initialize(),
+                tuples: [
+                  (() => {
+                    const tuple = MetadataTuple.create({
+                      tags: [],
+                      type: MetadataTupleType.create({
+                        name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                        index: null,
+                        recursive: false,
+                        nullables: [],
+                        elements: [m.key, m.value],
+                      }),
+                    });
+                    tuple.type.of_map = true;
+                    return tuple;
+                  })(),
+                ],
+              }),
+            }),
+          }),
+      },
+      parameters: props.parameters,
+      input: props.input,
+      definitions: props.maps,
+      explore: props.explore,
+    });
+
+  export namespace map {
+    export type IConfig = check_union_array_like.IConfig<
+      MetadataArray,
+      [MetadataSchema, MetadataSchema]
+    >;
+  }
+}