typia 8.0.3 → 8.1.0

package/lib/programmers/CheckerProgrammer.d.mts

@@ -0,0 +1,125 @@
+import ts from "typescript";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { ITypiaContext } from "../transformers/ITypiaContext";
+import { FeatureProgrammer } from "./FeatureProgrammer";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
+import { ICheckEntry } from "./helpers/ICheckEntry";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+export declare namespace CheckerProgrammer {
+    interface IConfig {
+        prefix: string;
+        path: boolean;
+        trace: boolean;
+        equals: boolean;
+        numeric: boolean;
+        addition?: () => ts.Statement[];
+        decoder?: (props: {
+            metadata: Metadata;
+            input: ts.Expression;
+            explore: IExplore;
+        }) => ts.Expression;
+        combiner: IConfig.Combiner;
+        atomist: (props: {
+            entry: ICheckEntry;
+            input: ts.Expression;
+            explore: IExplore;
+        }) => ts.Expression;
+        joiner: IConfig.IJoiner;
+        success: ts.Expression;
+    }
+    namespace IConfig {
+        interface Combiner {
+            (props: {
+                explore: IExplore;
+                logic: "and" | "or";
+                input: ts.Expression;
+                binaries: IBinary[];
+                expected: string;
+            }): ts.Expression;
+        }
+        interface IJoiner {
+            object(props: {
+                input: ts.Expression;
+                entries: IExpressionEntry<ts.Expression>[];
+            }): ts.Expression;
+            array(props: {
+                input: ts.Expression;
+                arrow: ts.ArrowFunction;
+            }): ts.Expression;
+            tuple?: undefined | ((exprs: ts.Expression[]) => ts.Expression);
+            failure(props: {
+                input: ts.Expression;
+                expected: string;
+                explore?: undefined | FeatureProgrammer.IExplore;
+            }): ts.Expression;
+            is?(expression: ts.Expression): ts.Expression;
+            required?(exp: ts.Expression): ts.Expression;
+            full?: undefined | ((props: {
+                condition: ts.Expression;
+                input: ts.Expression;
+                expected: string;
+                explore: IExplore;
+            }) => ts.Expression);
+        }
+    }
+    type IExplore = FeatureProgrammer.IExplore;
+    interface IBinary {
+        expression: ts.Expression;
+        combined: boolean;
+    }
+    const compose: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IComposed;
+    const write: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name?: string;
+    }) => ts.ArrowFunction;
+    const write_object_functions: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        collection: MetadataCollection;
+    }) => ts.VariableStatement[];
+    const write_union_functions: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        collection: MetadataCollection;
+    }) => ts.VariableStatement[];
+    const write_array_functions: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        collection: MetadataCollection;
+    }) => ts.VariableStatement[];
+    const write_tuple_functions: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        collection: MetadataCollection;
+    }) => ts.VariableStatement[];
+    const decode: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        input: ts.Expression;
+        metadata: Metadata;
+        explore: IExplore;
+    }) => ts.Expression;
+    const decode_object: (props: {
+        config: IConfig;
+        functor: FunctionProgrammer;
+        object: MetadataObjectType;
+        input: ts.Expression;
+        explore: IExplore;
+    }) => ts.CallExpression;
+}

package/lib/programmers/FeatureProgrammer.d.mts

@@ -0,0 +1,249 @@
+import ts from "typescript";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataArray } from "../schemas/metadata/MetadataArray";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { ITypiaContext } from "../transformers/ITypiaContext";
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+export declare namespace FeatureProgrammer {
+    interface IConfig<Output extends ts.ConciseBody = ts.ConciseBody> {
+        types: IConfig.ITypes;
+        /**
+         * Prefix name of internal functions for specific types.
+         */
+        prefix: string;
+        /**
+         * Whether to archive access path or not.
+         */
+        path: boolean;
+        /**
+         * Whether to trace exception or not.
+         */
+        trace: boolean;
+        addition?: undefined | ((collection: MetadataCollection) => ts.Statement[]);
+        /**
+         * Initializer of metadata.
+         */
+        initializer: (props: {
+            context: ITypiaContext;
+            functor: FunctionProgrammer;
+            type: ts.Type;
+        }) => {
+            collection: MetadataCollection;
+            metadata: Metadata;
+        };
+        /**
+         * Decoder, station of every types.
+         */
+        decoder: (props: {
+            metadata: Metadata;
+            input: ts.Expression;
+            explore: IExplore;
+        }) => Output;
+        /**
+         * Object configurator.
+         */
+        objector: IConfig.IObjector<Output>;
+        /**
+         * Generator of functions for object types.
+         */
+        generator: IConfig.IGenerator;
+    }
+    namespace IConfig {
+        interface ITypes {
+            input: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
+            output: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
+        }
+        interface IObjector<Output extends ts.ConciseBody = ts.ConciseBody> {
+            /**
+             * Type checker when union object type comes.
+             */
+            checker: (props: {
+                metadata: Metadata;
+                input: ts.Expression;
+                explore: IExplore;
+            }) => ts.Expression;
+            /**
+             * Decoder, function call expression generator of specific typed objects.
+             */
+            decoder: (props: {
+                input: ts.Expression;
+                object: MetadataObjectType;
+                explore: IExplore;
+            }) => ts.Expression;
+            /**
+             * Joiner of expressions from properties.
+             */
+            joiner(props: {
+                entries: IExpressionEntry<Output>[];
+                input?: ts.Expression;
+                object?: MetadataObjectType;
+            }): ts.ConciseBody;
+            /**
+             * Union type specificator.
+             *
+             * Expression of an algorithm specifying object type and calling
+             * the `decoder` function of the specified object type.
+             */
+            unionizer: (props: {
+                objects: MetadataObjectType[];
+                input: ts.Expression;
+                explore: IExplore;
+            }) => ts.Expression;
+            /**
+             * Handler of union type specification failure.
+             *
+             * @param props Properties of failure
+             * @returns Statement of failure
+             */
+            failure(props: {
+                input: ts.Expression;
+                expected: string;
+                explore?: undefined | IExplore;
+            }): ts.Statement;
+            /**
+             * Transformer of type checking expression by discrimination.
+             *
+             * When an object type has been specified by a discrimination without full
+             * iteration, the `unionizer` will decode the object instance after
+             * the last type checking.
+             *
+             * In such circumtance, you can transform the last type checking function.
+             *
+             * @param exp Current expression about type checking
+             * @returns Transformed expression
+             * @deprecated
+             */
+            is?: undefined | ((exp: ts.Expression) => ts.Expression);
+            /**
+             * Transformer of non-undefined type checking by discrimination.
+             *
+             * When specifying an union type of objects, `typia` tries to find
+             * discrimination way just by checking only one property type.
+             * If succeeded to find the discrimination way, `typia` will check the target
+             * property type and in the checking, non-undefined type checking would be
+             * done.
+             *
+             * In such process, you can transform the non-undefined type checking.
+             *
+             * @param exp
+             * @returns Transformed expression
+             * @deprecated
+             */
+            required?: undefined | ((exp: ts.Expression) => ts.Expression);
+            /**
+             * Condition wrapper when unable to specify any object type.
+             *
+             * When failed to specify an object type through discrimination, full
+             * iteration type checking would be happened. In such circumstance, you
+             * can wrap the condition with additional function.
+             *
+             * @param props Properties of condition
+             * @returns The wrapper expression
+             */
+            full?: undefined | ((props: {
+                condition: ts.Expression;
+                input: ts.Expression;
+                expected: string;
+                explore: IExplore;
+            }) => ts.Expression);
+            /**
+             * Return type.
+             */
+            type?: undefined | ts.TypeNode;
+        }
+        interface IGenerator {
+            objects?: undefined | ((collection: MetadataCollection) => ts.VariableStatement[]);
+            unions?: undefined | ((collection: MetadataCollection) => ts.VariableStatement[]);
+            arrays: (collection: MetadataCollection) => ts.VariableStatement[];
+            tuples: (collection: MetadataCollection) => ts.VariableStatement[];
+        }
+    }
+    interface IExplore {
+        tracable: boolean;
+        source: "top" | "function";
+        from: "top" | "array" | "object";
+        postfix: string;
+        start?: undefined | number;
+    }
+    type Decoder<T, Output extends ts.ConciseBody = ts.ConciseBody> = (props: {
+        input: ts.Expression;
+        definition: T;
+        explore: IExplore;
+    }) => Output;
+    interface IComposed {
+        body: ts.ConciseBody;
+        parameters: ts.ParameterDeclaration[];
+        functions: Record<string, ts.VariableStatement>;
+        statements: ts.Statement[];
+        response: ts.TypeNode;
+    }
+    interface IDecomposed {
+        functions: Record<string, ts.VariableStatement>;
+        statements: ts.Statement[];
+        arrow: ts.ArrowFunction;
+    }
+    const compose: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => IComposed;
+    const writeDecomposed: (props: {
+        modulo: ts.LeftHandSideExpression;
+        functor: FunctionProgrammer;
+        result: IDecomposed;
+    }) => ts.CallExpression;
+    const write: (props: {
+        context: ITypiaContext;
+        config: IConfig;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name?: string | undefined;
+    }) => ts.ArrowFunction;
+    const write_object_functions: (props: {
+        config: IConfig;
+        context: ITypiaContext;
+        collection: MetadataCollection;
+    }) => ts.VariableStatement[];
+    const write_union_functions: (props: {
+        config: IConfig;
+        collection: MetadataCollection;
+    }) => ts.VariableStatement[];
+    const decode_array: (props: {
+        config: Pick<IConfig, "trace" | "path" | "decoder" | "prefix">;
+        functor: FunctionProgrammer;
+        combiner: (next: {
+            input: ts.Expression;
+            arrow: ts.ArrowFunction;
+        }) => ts.Expression;
+        array: MetadataArray;
+        input: ts.Expression;
+        explore: IExplore;
+    }) => ts.Expression;
+    const decode_object: (props: {
+        config: Pick<IConfig, "trace" | "path" | "prefix">;
+        functor: FunctionProgrammer;
+        object: MetadataObjectType;
+        input: ts.Expression;
+        explore: IExplore;
+    }) => ts.CallExpression;
+    const index: (props: {
+        start: number | null;
+        postfix: string;
+        rand: string;
+    }) => string;
+    const argumentsArray: (props: {
+        config: Pick<IConfig, "path" | "trace">;
+        input: ts.Expression;
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.Expression[];
+    const parameterDeclarations: (props: {
+        config: Pick<CheckerProgrammer.IConfig, "path" | "trace">;
+        type: ts.TypeNode;
+        input: ts.Identifier;
+    }) => ts.ParameterDeclaration[];
+}

package/lib/programmers/ImportProgrammer.d.mts

@@ -0,0 +1,35 @@
+import ts from "typescript";
+export declare class ImportProgrammer {
+    private readonly assets_;
+    private readonly options_;
+    constructor(options?: Partial<ImportProgrammer.IOptions>);
+    default(props: ImportProgrammer.IDefault): ts.Identifier;
+    instance(props: ImportProgrammer.IInstance): ts.Identifier;
+    namespace(props: ImportProgrammer.INamespace): ts.Identifier;
+    type(props: {
+        file: string;
+        name: string | ts.EntityName;
+        arguments?: ts.TypeNode[];
+    }): ts.ImportTypeNode;
+    private alias;
+    toStatements(): ts.ImportDeclaration[];
+}
+export declare namespace ImportProgrammer {
+    interface IOptions {
+        internalPrefix: string;
+    }
+    interface IDefault {
+        file: string;
+        name: string;
+        type: boolean;
+    }
+    interface IInstance {
+        file: string;
+        name: string;
+        alias: string | null;
+    }
+    interface INamespace {
+        file: string;
+        name: string;
+    }
+}

package/lib/programmers/IsProgrammer.d.mts

@@ -0,0 +1,65 @@
+import ts from "typescript";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { IProgrammerProps } from "../transformers/IProgrammerProps";
+import { ITypiaContext } from "../transformers/ITypiaContext";
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { FeatureProgrammer } from "./FeatureProgrammer";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+export declare namespace IsProgrammer {
+    const configure: (props: {
+        options?: Partial<CONFIG.IOptions>;
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+    }) => CheckerProgrammer.IConfig;
+    namespace CONFIG {
+        interface IOptions {
+            numeric: boolean;
+            undefined: boolean;
+            object: (props: {
+                input: ts.Expression;
+                entries: IExpressionEntry<ts.Expression>[];
+            }) => ts.Expression;
+        }
+    }
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps extends IProgrammerProps {
+        config: IConfig;
+    }
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        config: IConfig;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProps) => ts.CallExpression;
+    const write_function_statements: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        collection: MetadataCollection;
+    }) => ts.VariableStatement[];
+    const decode: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        metadata: Metadata;
+        input: ts.Expression;
+        explore: CheckerProgrammer.IExplore;
+    }) => ts.Expression;
+    const decode_object: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        object: MetadataObjectType;
+        input: ts.Expression;
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.CallExpression;
+    const decode_to_json: (props: {
+        input: ts.Expression;
+        checkNull: boolean;
+    }) => ts.Expression;
+    const decode_functional: (input: ts.Expression) => ts.BinaryExpression;
+}

package/lib/programmers/RandomProgrammer.d.mts

@@ -0,0 +1,22 @@
+import ts from "typescript";
+import { ITypiaContext } from "../transformers/ITypiaContext";
+import { FeatureProgrammer } from "./FeatureProgrammer";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
+export declare namespace RandomProgrammer {
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        type: ts.Type;
+        name: string | undefined;
+        init: ts.Expression | undefined;
+    }
+    interface IDecomposeProps {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+        init: ts.Expression | undefined;
+    }
+    const decompose: (props: IDecomposeProps) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProps) => ts.CallExpression;
+}

package/lib/programmers/TypiaProgrammer.d.mts

@@ -0,0 +1,8 @@
+export declare namespace TypiaProgrammer {
+    interface ILocation {
+        input: string;
+        output: string;
+        project: string;
+    }
+    const build: (location: TypiaProgrammer.ILocation) => Promise<void>;
+}

package/lib/programmers/ValidateProgrammer.d.mts

@@ -0,0 +1,22 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../transformers/IProgrammerProps";
+import { ITypiaContext } from "../transformers/ITypiaContext";
+import { FeatureProgrammer } from "./FeatureProgrammer";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
+export declare namespace ValidateProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps extends IProgrammerProps {
+        config: IConfig;
+    }
+    const decompose: (props: {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        functor: FunctionProgrammer;
+        config: IConfig;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProps) => ts.CallExpression;
+}

package/lib/programmers/functional/FunctionalAssertFunctionProgrammer.d.mts

@@ -0,0 +1,28 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalAssertFunctionProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const errorFactoryWrapper: (props: {
+        context: ITypiaContext;
+        parameters: readonly ts.ParameterDeclaration[];
+        init: ts.Expression | undefined;
+    }) => {
+        name: string;
+        variable: ts.VariableStatement;
+    };
+    const hookPath: (props: {
+        wrapper: string;
+        replacer: string;
+    }) => ts.ArrowFunction;
+}

package/lib/programmers/functional/FunctionalAssertParametersProgrammer.d.mts

@@ -0,0 +1,28 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalAssertParametersProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    interface IDecomposeProps {
+        context: ITypiaContext;
+        config: IConfig;
+        modulo: ts.LeftHandSideExpression;
+        parameters: readonly ts.ParameterDeclaration[];
+        wrapper: string;
+    }
+    interface IDecomposeOutput {
+        functions: ts.Statement[];
+        expressions: ts.Expression[];
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const decompose: (props: IDecomposeProps) => IDecomposeOutput;
+}

package/lib/programmers/functional/FunctionalAssertReturnProgrammer.d.mts

@@ -0,0 +1,30 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionAssertReturnProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        expression: ts.Expression;
+        declaration: ts.FunctionDeclaration;
+        init?: ts.Expression | undefined;
+    }
+    interface IDecomposeProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        expression: ts.Expression;
+        declaration: ts.FunctionDeclaration;
+        wrapper: string;
+    }
+    interface IDecomposeOutput {
+        async: boolean;
+        functions: ts.Statement[];
+        value: ts.Expression;
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const decompose: (props: IDecomposeProps) => IDecomposeOutput;
+}

package/lib/programmers/functional/FunctionalIsFunctionProgrammer.d.mts

@@ -0,0 +1,20 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalIsFunctionProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const getReturnTypeNode: (props: {
+        declaration: ts.FunctionDeclaration;
+        async: boolean;
+    }) => ts.TypeNode | undefined;
+}

package/lib/programmers/functional/FunctionalIsParametersProgrammer.d.mts

@@ -0,0 +1,27 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalIsParametersProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    interface IDecomposeProps {
+        context: ITypiaContext;
+        config: IConfig;
+        modulo: ts.LeftHandSideExpression;
+        declaration: ts.FunctionDeclaration;
+    }
+    interface IDecomposeOutput {
+        functions: ts.Statement[];
+        statements: ts.Statement[];
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const decompose: (props: IDecomposeProps) => IDecomposeOutput;
+}