typia 7.2.1 → 7.3.0-dev.20241213

package/src/programmers/http/HttpValidateFormDataProgrammer.ts

@@ -1,92 +1,92 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
-
-export namespace HttpValidateFormDataProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate = ValidateProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      config: {
-        equals: false,
-      },
-    });
-    const decode = HttpFormDataProgrammer.decompose(props);
-    return {
-      functions: {
-        ...validate.functions,
-        ...decode.functions,
-      },
-      statements: [
-        ...validate.statements,
-        StatementFactory.constant({
-          name: "__validate",
-          value: validate.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__decode",
-          value: decode.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        decode.arrow.parameters,
-        props.context.importer.type({
-          file: "typia",
-          name: "IValidation",
-          arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
-        }),
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__validate"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__decode"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ],
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
+
+export namespace HttpValidateFormDataProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate = ValidateProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      config: {
+        equals: false,
+      },
+    });
+    const decode = HttpFormDataProgrammer.decompose(props);
+    return {
+      functions: {
+        ...validate.functions,
+        ...decode.functions,
+      },
+      statements: [
+        ...validate.statements,
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        decode.arrow.parameters,
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
+        }),
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__validate"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}

package/src/programmers/http/HttpValidateHeadersProgrammer.ts

@@ -1,92 +1,92 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-
-export namespace HttpValidateHeadersProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate = ValidateProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      config: {
-        equals: false,
-      },
-    });
-    const decode = HttpHeadersProgrammer.decompose(props);
-    return {
-      functions: {
-        ...validate.functions,
-        ...decode.functions,
-      },
-      statements: [
-        ...validate.statements,
-        StatementFactory.constant({
-          name: "__validate",
-          value: validate.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__decode",
-          value: decode.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        decode.arrow.parameters,
-        props.context.importer.type({
-          file: "typia",
-          name: "IValidation",
-          arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
-        }),
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__validate"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__decode"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ],
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+
+export namespace HttpValidateHeadersProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate = ValidateProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      config: {
+        equals: false,
+      },
+    });
+    const decode = HttpHeadersProgrammer.decompose(props);
+    return {
+      functions: {
+        ...validate.functions,
+        ...decode.functions,
+      },
+      statements: [
+        ...validate.statements,
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        decode.arrow.parameters,
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
+        }),
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__validate"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}

package/src/programmers/http/HttpValidateQueryProgrammer.ts

@@ -1,98 +1,98 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
-
-export namespace HttpValidateQueryProgrammer {
-  export interface IProps extends IProgrammerProps {
-    allowOptional?: boolean;
-  }
-
-  export const decompose = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-    allowOptional: boolean;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate = ValidateProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      config: {
-        equals: false,
-      },
-    });
-    const decode = HttpQueryProgrammer.decompose(props);
-    return {
-      functions: {
-        ...validate.functions,
-        ...decode.functions,
-      },
-      statements: [
-        ...validate.statements,
-        StatementFactory.constant({
-          name: "__validate",
-          value: validate.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__decode",
-          value: decode.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        decode.arrow.parameters,
-        props.context.importer.type({
-          file: "typia",
-          name: "IValidation",
-          arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
-        }),
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__validate"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__decode"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ],
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-      allowOptional: !!props.allowOptional,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
+
+export namespace HttpValidateQueryProgrammer {
+  export interface IProps extends IProgrammerProps {
+    allowOptional?: boolean;
+  }
+
+  export const decompose = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+    allowOptional: boolean;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate = ValidateProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      config: {
+        equals: false,
+      },
+    });
+    const decode = HttpQueryProgrammer.decompose(props);
+    return {
+      functions: {
+        ...validate.functions,
+        ...decode.functions,
+      },
+      statements: [
+        ...validate.statements,
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        decode.arrow.parameters,
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
+        }),
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__validate"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+      allowOptional: !!props.allowOptional,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}

package/src/programmers/internal/check_array_length.ts

@@ -1,47 +1,47 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_array_length = (props: {
-  context: ITypiaContext;
-  array: MetadataArray;
-  input: ts.Expression;
-}): ICheckEntry => {
-  const conditions: ICheckEntry.ICondition[][] = check_array_type_tags(props);
-  return {
-    expected: props.array.getName(),
-    expression: null,
-    conditions,
-  };
-};
-
-/**
- * @internal
- */
-const check_array_type_tags = (props: {
-  context: ITypiaContext;
-  array: MetadataArray;
-  input: ts.Expression;
-}): ICheckEntry.ICondition[][] =>
-  props.array.tags
-    .map((row) => row.filter((tag) => !!tag.validate))
-    .filter((row) => !!row.length)
-    .map((row) =>
-      row.map((tag) => ({
-        expected: `Array<> & ${tag.name}`,
-        expression: ExpressionFactory.transpile({
-          transformer: props.context.transformer,
-          importer: props.context.importer,
-          script: tag.validate!,
-        })(props.input),
-      })),
-    );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_array_length = (props: {
+  context: ITypiaContext;
+  array: MetadataArray;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const conditions: ICheckEntry.ICondition[][] = check_array_type_tags(props);
+  return {
+    expected: props.array.getName(),
+    expression: null,
+    conditions,
+  };
+};
+
+/**
+ * @internal
+ */
+const check_array_type_tags = (props: {
+  context: ITypiaContext;
+  array: MetadataArray;
+  input: ts.Expression;
+}): ICheckEntry.ICondition[][] =>
+  props.array.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) =>
+      row.map((tag) => ({
+        expected: `Array<> & ${tag.name}`,
+        expression: ExpressionFactory.transpile({
+          transformer: props.context.transformer,
+          importer: props.context.importer,
+          script: tag.validate!,
+        })(props.input),
+      })),
+    );