typia 3.8.9 → 3.9.0-dev.20230604

package/src/metadata/MetadataProperty.ts

@@ -1,15 +1,15 @@
 import { ClassProperties } from "../typings/ClassProperties";
 
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataDictionary } from "./IMetadataDictionary";
 import { IMetadataProperty } from "./IMetadataProperty";
 import { IMetadataTag } from "./IMetadataTag";
 import { Metadata } from "./Metadata";
-import { MetadataObject } from "./MetadataObject";
 
 export class MetadataProperty {
     public readonly key: Metadata;
     public readonly value: Metadata;
-    public readonly description: string | undefined;
+    public readonly description: string | null;
     public readonly tags: IMetadataTag[];
     public readonly jsDocTags: IJsDocTagInfo[];
 
@@ -41,11 +41,11 @@ export class MetadataProperty {
      */
     public static _From(
         property: IMetadataProperty,
-        objects: Map<string, MetadataObject>,
+        dict: IMetadataDictionary,
     ) {
         return this.create({
-            key: Metadata._From(property.key, objects),
-            value: Metadata._From(property.value, objects),
+            key: Metadata._From(property.key, dict),
+            value: Metadata._From(property.value, dict),
             description: property.description,
             tags: property.tags.slice(),
             jsDocTags: property.jsDocTags.slice(),

package/src/metadata/MetadataTuple.ts

@@ -0,0 +1,53 @@
+import { ClassProperties } from "../typings/ClassProperties";
+
+import { IMetadataTuple } from "./IMetadataTuple";
+import { Metadata } from "./Metadata";
+
+export class MetadataTuple {
+    public readonly name: string;
+    public readonly elements: Metadata[];
+
+    public readonly index: number | null;
+    public readonly recursive: boolean;
+    public readonly nullables: boolean[];
+
+    /**
+     * @internal
+     */
+    private constructor(props: ClassProperties<MetadataTuple>) {
+        this.name = props.name;
+        this.elements = props.elements;
+        this.index = props.index;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_elements(
+        props: Omit<IMetadataTuple, "elements">,
+    ): MetadataTuple {
+        return this.create({
+            name: props.name,
+            index: props.index,
+            elements: null!,
+            recursive: props.recursive,
+            nullables: props.nullables.slice(),
+        });
+    }
+
+    public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
+        return new MetadataTuple(props);
+    }
+
+    public toJSON(): IMetadataTuple {
+        return {
+            name: this.name,
+            index: this.index,
+            elements: this.elements.map((elem) => elem.toJSON()),
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}

package/src/programmers/ApplicationProgrammer.ts

@@ -35,7 +35,7 @@ export namespace ApplicationProgrammer {
         (metadatas: Array<Metadata>): IJsonApplication => {
             const fullOptions: IOptions = IOptions.complement(options);
             const components: IJsonComponents = {
-                schemas: {},
+                objects: {},
             };
             const generator = application_schema(fullOptions)(true)(components);
 
@@ -50,7 +50,6 @@ export namespace ApplicationProgrammer {
                 }),
                 components,
                 ...fullOptions,
-                prefix: "#/components/schemas",
             };
         };
 }

package/src/programmers/AssertProgrammer.ts

@@ -31,9 +31,12 @@ export namespace AssertProgrammer {
         (equals: boolean) =>
         (type: ts.Type, name?: string) => {
             const importer: FunctionImporter = new FunctionImporter();
-            const program: ts.ArrowFunction = CheckerProgrammer.write(project)({
-                functors: "$ao",
-                unioners: "$au",
+            const is = IsProgrammer.write(project)(modulo, true)(equals)(
+                type,
+                name ?? TypeFactory.getFullName(project.checker)(type),
+            );
+            const assert: ts.ArrowFunction = CheckerProgrammer.write(project)({
+                prefix: "$a",
                 path: true,
                 trace: true,
                 numeric: OptionPredicator.numeric(project.options),
@@ -65,6 +68,7 @@ export namespace AssertProgrammer {
                 combiner: combiner(equals)(importer),
                 joiner: joiner(equals)(importer),
                 success: ts.factory.createTrue(),
+                addition: () => importer.declare(modulo),
             })(importer)(type, name);
 
             return ts.factory.createArrowFunction(
@@ -82,17 +86,7 @@ export namespace AssertProgrammer {
                 undefined,
                 ts.factory.createBlock(
                     [
-                        ...importer.declare(modulo),
-                        StatementFactory.constant(
-                            "__is",
-                            IsProgrammer.write(project)(modulo, true)(equals)(
-                                type,
-                                name ??
-                                    TypeFactory.getFullName(project.checker)(
-                                        type,
-                                    ),
-                            ),
-                        ),
+                        StatementFactory.constant("__is", is),
                         ts.factory.createIfStatement(
                             ts.factory.createStrictEquality(
                                 ts.factory.createFalse(),
@@ -104,7 +98,7 @@ export namespace AssertProgrammer {
                             ),
                             ts.factory.createExpressionStatement(
                                 ts.factory.createCallExpression(
-                                    program,
+                                    assert,
                                     undefined,
                                     [
                                         ts.factory.createIdentifier("input"),
@@ -161,30 +155,42 @@ export namespace AssertProgrammer {
                                     ),
                           )
                           .reduce(ts.factory.createLogicalAnd)
-                    : (() => {
-                          const addicted = binaries.slice();
-                          if (
-                              addicted[addicted.length - 1]!.combined === false
-                          ) {
-                              addicted.push({
-                                  combined: true,
-                                  expression: create_guard_call(importer)(
-                                      explore.source === "top"
-                                          ? ts.factory.createTrue()
-                                          : ts.factory.createIdentifier(
-                                                "_exceptionable",
-                                            ),
-                                  )(
-                                      ts.factory.createIdentifier(path),
-                                      expected,
-                                      input,
-                                  ),
-                              });
-                          }
-                          return addicted
-                              .map((b) => b.expression)
-                              .reduce(ts.factory.createLogicalOr);
-                      })();
+                    : ts.factory.createLogicalOr(
+                          binaries
+                              .map((binary) => binary.expression)
+                              .reduce(ts.factory.createLogicalOr),
+                          create_guard_call(importer)(
+                              explore.source === "top"
+                                  ? ts.factory.createTrue()
+                                  : ts.factory.createIdentifier(
+                                        "_exceptionable",
+                                    ),
+                          )(ts.factory.createIdentifier(path), expected, input),
+                      );
+            // : (() => {
+            //       const addicted = binaries.slice();
+            //       if (
+            //           addicted[addicted.length - 1]!.combined === false
+            //       ) {
+            //           addicted.push({
+            //               combined: true,
+            //               expression: create_guard_call(importer)(
+            //                   explore.source === "top"
+            //                       ? ts.factory.createTrue()
+            //                       : ts.factory.createIdentifier(
+            //                             "_exceptionable",
+            //                         ),
+            //               )(
+            //                   ts.factory.createIdentifier(path),
+            //                   expected,
+            //                   input,
+            //               ),
+            //           });
+            //       }
+            //       return addicted
+            //           .map((b) => b.expression)
+            //           .reduce(ts.factory.createLogicalOr);
+            //   })();
         };
 
     const assert_object = (equals: boolean) => (importer: FunctionImporter) =>