npm - typia - Versions diffs - 5.1.3 → 5.1.4-dev.20230929 - Mend

typia 5.1.3 → 5.1.4-dev.20230929

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (66) hide show

package/lib/executable/TypiaSetupWizard.js +1 -19
package/lib/executable/TypiaSetupWizard.js.map +1 -1
package/package.json +1 -1
package/src/executable/TypiaSetupWizard.ts +1 -16
package/src/factories/MetadataCollection.ts +277 -277
package/src/factories/MetadataFactory.ts +238 -238
package/src/factories/MetadataTypeTagFactory.ts +325 -325
package/src/factories/internal/metadata/emend_metadata_atomics.ts +41 -41
package/src/factories/internal/metadata/iterate_metadata_intersection.ts +259 -259
package/src/functional/$HeadersReader.ts +28 -28
package/src/functional/$ParameterReader.ts +31 -31
package/src/functional/$QueryReader.ts +56 -56
package/src/functional/Namespace.ts +142 -142
package/src/http.ts +1149 -1149
package/src/json.ts +648 -648
package/src/misc.ts +651 -651
package/src/module.ts +657 -657
package/src/programmers/helpers/HttpMetadataUtil.ts +21 -21
package/src/programmers/http/HttpAssertHeadersProgrammer.ts +77 -77
package/src/programmers/http/HttpAssertQueryProgrammer.ts +77 -77
package/src/programmers/http/HttpHeadersProgrammer.ts +339 -339
package/src/programmers/http/HttpIsHeadersProgrammer.ts +87 -87
package/src/programmers/http/HttpIsQueryProgrammer.ts +87 -87
package/src/programmers/http/HttpParameterProgrammer.ts +104 -104
package/src/programmers/http/HttpQueryProgrammer.ts +273 -273
package/src/programmers/http/HttpValidateHeadersProgrammer.ts +77 -77
package/src/programmers/http/HttpValidateQueryProgrammer.ts +77 -77
package/src/programmers/internal/application_boolean.ts +30 -30
package/src/programmers/internal/application_number.ts +90 -90
package/src/programmers/internal/application_schema.ts +180 -180
package/src/programmers/internal/application_string.ts +54 -54
package/src/programmers/internal/check_array_length.ts +44 -44
package/src/programmers/internal/check_bigint.ts +48 -48
package/src/programmers/internal/check_number.ts +108 -108
package/src/programmers/internal/check_string.ts +48 -48
package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts +882 -882
package/src/protobuf.ts +887 -887
package/src/schemas/json/IJsonComponents.ts +34 -34
package/src/schemas/json/IJsonSchema.ts +112 -112
package/src/schemas/metadata/IMetadataConstant.ts +25 -25
package/src/schemas/metadata/IMetadataTypeTag.ts +8 -8
package/src/schemas/metadata/Metadata.ts +686 -686
package/src/tags/Default.ts +15 -15
package/src/tags/Format.ts +30 -30
package/src/tags/Pattern.ts +9 -9
package/src/tags/TagBase.ts +68 -68
package/src/tags/index.ts +14 -14
package/src/transformers/CallExpressionTransformer.ts +289 -289
package/src/transformers/features/http/CreateHttpAssertHeadersTransformer.ts +12 -12
package/src/transformers/features/http/CreateHttpAssertQueryTransformer.ts +12 -12
package/src/transformers/features/http/CreateHttpHeadersTransformer.ts +9 -9
package/src/transformers/features/http/CreateHttpIsHeadersTransformer.ts +9 -9
package/src/transformers/features/http/CreateHttpIsQueryTransformer.ts +9 -9
package/src/transformers/features/http/CreateHttpParameterTransformer.ts +9 -9
package/src/transformers/features/http/CreateHttpQueryTransformer.ts +9 -9
package/src/transformers/features/http/CreateHttpValidateHeadersTransformer.ts +12 -12
package/src/transformers/features/http/CreateHttpValidateQueryTransformer.ts +12 -12
package/src/transformers/features/http/HttpAssertHeadersTransformer.ts +10 -10
package/src/transformers/features/http/HttpAssertQueryTransformer.ts +10 -10
package/src/transformers/features/http/HttpHeadersTransformer.ts +9 -9
package/src/transformers/features/http/HttpIsHeadersTransformer.ts +9 -9
package/src/transformers/features/http/HttpIsQueryTransformer.ts +9 -9
package/src/transformers/features/http/HttpParameterTransformer.ts +9 -9
package/src/transformers/features/http/HttpQueryTransformer.ts +9 -9
package/src/transformers/features/http/HttpValidateHeadersTransformer.ts +10 -10
package/src/transformers/features/http/HttpValidateQueryTransformer.ts +10 -10

package/src/programmers/http/HttpIsHeadersProgrammer.ts CHANGED Viewed

@@ -1,87 +1,87 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-import { IProject } from "../../transformers/IProject";
-import { IsProgrammer } from "../IsProgrammer";
-import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-export namespace HttpIsHeadersProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpHeadersProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createUnionTypeNode([
-                    ts.factory.createTypeReferenceNode(
-                        `typia.Resolved<${
-                            name ??
-                            TypeFactory.getFullName(project.checker)(type)
-                        }>`,
-                    ),
-                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
-                ]),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "is",
-                        IsProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "headers",
-                        HttpHeadersProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("headers"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createPrefixUnaryExpression(
-                            ts.SyntaxKind.ExclamationToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                        ),
-                        ts.factory.createReturnStatement(
-                            ts.factory.createNull(),
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { IProject } from "../../transformers/IProject";
+import { IsProgrammer } from "../IsProgrammer";
+import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+export namespace HttpIsHeadersProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpHeadersProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createTypeReferenceNode(
+                        `typia.Resolved<${
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
+                        }>`,
+                    ),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                ]),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "headers",
+                        HttpHeadersProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("headers"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createNull(),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/http/HttpIsQueryProgrammer.ts CHANGED Viewed

@@ -1,87 +1,87 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-import { IProject } from "../../transformers/IProject";
-import { IsProgrammer } from "../IsProgrammer";
-import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
-export namespace HttpIsQueryProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpQueryProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createUnionTypeNode([
-                    ts.factory.createTypeReferenceNode(
-                        `typia.Resolved<${
-                            name ??
-                            TypeFactory.getFullName(project.checker)(type)
-                        }>`,
-                    ),
-                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
-                ]),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "is",
-                        IsProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "query",
-                        HttpQueryProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("query"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createPrefixUnaryExpression(
-                            ts.SyntaxKind.ExclamationToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                        ),
-                        ts.factory.createReturnStatement(
-                            ts.factory.createNull(),
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { IProject } from "../../transformers/IProject";
+import { IsProgrammer } from "../IsProgrammer";
+import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
+export namespace HttpIsQueryProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpQueryProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createTypeReferenceNode(
+                        `typia.Resolved<${
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
+                        }>`,
+                    ),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                ]),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "query",
+                        HttpQueryProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("query"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createNull(),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/http/HttpParameterProgrammer.ts CHANGED Viewed

@@ -1,104 +1,104 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { IProject } from "../../transformers/IProject";
-import { TransformerError } from "../../transformers/TransformerError";
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
-export namespace HttpParameterProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction => {
-            const result = MetadataFactory.analyze(project.checker)({
-                escape: false,
-                constant: true,
-                absorb: true,
-                validate,
-            })(new MetadataCollection())(type);
-            if (result.success === false)
-                throw TransformerError.from(modulo.getText())(result.errors);
-            const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
-            const importer: FunctionImporter = new FunctionImporter(
-                modulo.getText(),
-            );
-            const block: ts.Statement[] = [
-                StatementFactory.constant(
-                    "assert",
-                    AssertProgrammer.write({
-                        ...project,
-                        options: {
-                            numeric: true,
-                        },
-                    })(modulo)(false)(type, name),
-                ),
-                StatementFactory.constant(
-                    "value",
-                    ts.factory.createCallExpression(
-                        importer.use(atomic),
-                        undefined,
-                        [ts.factory.createIdentifier("input")],
-                    ),
-                ),
-                ts.factory.createReturnStatement(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("assert"),
-                        undefined,
-                        [ts.factory.createIdentifier("value")],
-                    ),
-                ),
-            ];
-            return ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode("string"),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker)(type),
-                ),
-                undefined,
-                ts.factory.createBlock(
-                    [...importer.declare(modulo), ...block],
-                    true,
-                ),
-            );
-        };
-    export const validate = (meta: Metadata): string[] => {
-        const errors: string[] = [];
-        const insert = (msg: string) => errors.push(msg);
-        if (meta.any) insert("do not allow any type");
-        if (meta.isRequired() === false)
-            insert("do not allow undefindable type");
-        const atomics = HttpMetadataUtil.atomics(meta);
-        const expected: number =
-            meta.atomics.length +
-            meta.templates.length +
-            meta.constants
-                .map((c) => c.values.length)
-                .reduce((a, b) => a + b, 0);
-        if (meta.size() !== expected || atomics.size === 0)
-            insert("only atomic or constant types are allowed");
-        if (atomics.size > 1) insert("do not allow union type");
-        return errors;
-    };
-}
+import ts from "typescript";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
+export namespace HttpParameterProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            const result = MetadataFactory.analyze(project.checker)({
+                escape: false,
+                constant: true,
+                absorb: true,
+                validate,
+            })(new MetadataCollection())(type);
+            if (result.success === false)
+                throw TransformerError.from(modulo.getText())(result.errors);
+            const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
+            const block: ts.Statement[] = [
+                StatementFactory.constant(
+                    "assert",
+                    AssertProgrammer.write({
+                        ...project,
+                        options: {
+                            numeric: true,
+                        },
+                    })(modulo)(false)(type, name),
+                ),
+                StatementFactory.constant(
+                    "value",
+                    ts.factory.createCallExpression(
+                        importer.use(atomic),
+                        undefined,
+                        [ts.factory.createIdentifier("input")],
+                    ),
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("assert"),
+                        undefined,
+                        [ts.factory.createIdentifier("value")],
+                    ),
+                ),
+            ];
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode("string"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    name ?? TypeFactory.getFullName(project.checker)(type),
+                ),
+                undefined,
+                ts.factory.createBlock(
+                    [...importer.declare(modulo), ...block],
+                    true,
+                ),
+            );
+        };
+    export const validate = (meta: Metadata): string[] => {
+        const errors: string[] = [];
+        const insert = (msg: string) => errors.push(msg);
+        if (meta.any) insert("do not allow any type");
+        if (meta.isRequired() === false)
+            insert("do not allow undefindable type");
+        const atomics = HttpMetadataUtil.atomics(meta);
+        const expected: number =
+            meta.atomics.length +
+            meta.templates.length +
+            meta.constants
+                .map((c) => c.values.length)
+                .reduce((a, b) => a + b, 0);
+        if (meta.size() !== expected || atomics.size === 0)
+            insert("only atomic or constant types are allowed");
+        if (atomics.size > 1) insert("do not allow union type");
+        return errors;
+    };
+}