t pMerge branch 'v3.3'

samchon · Oct 3, 2022 · 67d50e5 · 67d50e5
2 parents 1b51534 + 780872b
commit 67d50e5
Show file tree

Hide file tree

Showing 66 changed files with 1,280 additions and 248 deletions.
diff --git a/README.md b/README.md
@@ -204,13 +204,14 @@ Also, only `typescript-json` can validate union typed structure exactly. All the
 Components               | `TSON` | `T.IS` | `ajv` | `io-ts` | `C.V.`
 -------------------------|-------------------|-----------------|-------|---------|------------------
 **Easy to use**          | ✔                | ✔               | ❌    | ❌     | ❌ 
-[Additional Tags](https://github.com/samchon/typescript-json/#comment-tags)        | ✔                | ❌              | ✔     | ✔      | ✔
-[Template Literal Types](https://github.com/samchon/typescript-json/blob/master/test/structures/TemplateUnion.ts) | ✅               | ❌              | ❌    | ❌     | ❌
 [Object (simple)](https://github.com/samchon/typescript-json/blob/master/test/structures/ObjectSimple.ts)          | ✔                | ✔               | ✔     | ✔      | ✔
 [Object (hierarchical)](https://github.com/samchon/typescript-json/blob/master/test/structures/ObjectHierarchical.ts)    | ✔                | ✔               | ❌    | ✔      | ✔
 [Object (recursive)](https://github.com/samchon/typescript-json/blob/master/test/structures/ObjectRecursive.ts)       | ✔                | ✔               | ✔     | ✔      | ✔
 [Object (union, implicit)](https://github.com/samchon/typescript-json/blob/master/test/structures/ObjectUnionImplicit.ts) | ✅               | ❌              | ❌    | ❌     | ❌
 [Object (union, explicit)](https://github.com/samchon/typescript-json/blob/master/test/structures/ObjectUnionExplicit.ts) | ✔               | ❌              | ✔    | ✔      | ❌
+[Object (additional tags)](https://github.com/samchon/typescript-json/#comment-tags)        | ✔                | ❌              | ✔     | ✔      | ✔
+[Object (template literal types)](https://github.com/samchon/typescript-json/blob/master/test/structures/TemplateUnion.ts) | ✅               | ❌              | ❌    | ❌     | ❌
+[Object (dynamic properties)](https://github.com/samchon/typescript-json/blob/master/test/structures/DynamicTemplate.ts) | ✔                | ❌              | ✔    | ❌     | ❌
 [Array (hierarchical)](https://github.com/samchon/typescript-json/blob/master/test/structures/ArrayHierarchical.ts)     | ✔                | ✔               | ❌    | ✔      | ✔
 [Array (recursive)](https://github.com/samchon/typescript-json/blob/master/test/structures/ArrayRecursive.ts)        | ✔                | ✔               | ❌     | ✔      | ✔
 [Array (recursive, union)](https://github.com/samchon/typescript-json/blob/master/test/structures/ArrayRecursiveUnionExplicit.ts) | ✔                | ✔               | ❌    | ❌     | ❌

diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "typescript-json",
-  "version": "3.3.2",
+  "version": "3.3.3",
   "description": "Runtime type checkers and 5x faster JSON.stringify() function",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

diff --git a/src/factories/internal/emplace_metadata_object.ts b/src/factories/internal/emplace_metadata_object.ts
@@ -34,6 +34,42 @@ export const emplace_metadata_object =
                   ts.isPropertySignature(node) ||
                   ts.isTypeLiteralNode(node);
 
+        const insert =
+            (key: Metadata) =>
+            (value: Metadata) =>
+            (identifier: () => string) =>
+            (
+                symbol: ts.Symbol | undefined,
+                filter?: (doc: ts.JSDocTagInfo) => boolean,
+            ): MetadataProperty => {
+                // COMMENTS AND TAGS
+                const description: string | undefined =
+                    CommentFactory.generate(
+                        symbol?.getDocumentationComment(checker) || [],
+                    ) || undefined;
+                const jsDocTags: ts.JSDocTagInfo[] = (
+                    symbol?.getJsDocTags() || []
+                ).filter(filter || (() => true));
+
+                // THE PROPERTY
+                const property = MetadataProperty.create({
+                    key,
+                    value,
+                    description,
+                    jsDocTags,
+                    tags: MetadataTagFactory.generate(
+                        () => identifier(),
+                        value,
+                        jsDocTags,
+                    ),
+                });
+                obj.properties.push(property);
+                return property;
+            };
+
+        //----
+        // REGULAR PROPERTIES
+        //----
         for (const prop of parent.getProperties()) {
             // CHECK NODE IS A FORMAL PROPERTY
             const node: ts.PropertyDeclaration | undefined =
@@ -56,35 +92,36 @@ export const emplace_metadata_object =
             }
 
             // GET EXACT TYPE
-            const key: string = prop.name;
             const type: ts.Type = checker.getTypeOfSymbolAtLocation(prop, node);
-
-            // CHILD METADATA BY ADDITIONAL EXPLORATION
-            const child: Metadata = explore_metadata(checker)(options)(
+            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
+            const value: Metadata = explore_metadata(checker)(options)(
                 collection,
             )(type, false);
-            if (node.questionToken) Writable(child).required = false;
 
-            // ADD TO OBJECT PROPERTY
-            const property = MetadataProperty.create({
-                key: MetadataHelper.literal_to_metadata(key),
-                value: child,
-                description:
-                    CommentFactory.generate(
-                        prop.getDocumentationComment(checker),
-                    ) || undefined,
-            });
-            obj.properties.push(property);
-
-            // ASSIGN TAGS
-            property.tags.push(
-                ...MetadataTagFactory.generate(
-                    () => `${obj.name}.${key}`,
-                    child,
-                    prop.getJsDocTags(),
-                ),
+            // INSERT WITH REQUIRED CONFIGURATION
+            if (node.questionToken) Writable(value).required = false;
+            insert(key)(value)(() => `${obj.name}.${prop.name}`)(prop);
+        }
+
+        //----
+        // DYNAMIC PROPERTIES
+        //----
+        for (const index of checker.getIndexInfosOfType(parent)) {
+            // GET EXACT TYPE
+            const analyzer = (type: ts.Type) =>
+                explore_metadata(checker)(options)(collection)(type, false);
+            const key: Metadata = analyzer(index.keyType);
+            const value: Metadata = analyzer(index.type);
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            insert(key)(value)(() => `${obj.name}[${key.getName()}]`)(
+                index.declaration?.parent
+                    ? checker.getSymbolAtLocation(index.declaration.parent)
+                    : undefined,
+                (doc) => doc.name !== "default",
             );
-            property.jsDocTags.push(...prop.getJsDocTags());
+            Writable(value).required = false;
         }
+
         return obj;
     };
diff --git a/src/metadata/Metadata.ts b/src/metadata/Metadata.ts
@@ -217,6 +217,13 @@ export class Metadata {
             return this.constants[0]!.values[0] as string;
         else return null;
     }
+
+    /**
+     * @internal
+     */
+    public isSoleLiteral(): boolean {
+        return this.getSoleLiteral() !== null;
+    }
 }
 export namespace Metadata {
     export function intersects(

diff --git a/src/metadata/MetadataProperty.ts b/src/metadata/MetadataProperty.ts
@@ -19,21 +19,19 @@ export class MetadataProperty {
     /**
      * @hidden
      */
-    private constructor(
-        props: Omit<ClassProperties<MetadataProperty>, "tags" | "jsDocTags">,
-    ) {
+    private constructor(props: ClassProperties<MetadataProperty>) {
         this.key = props.key;
         this.value = props.value;
         this.description = props.description;
-        this.tags = [];
-        this.jsDocTags = [];
+        this.tags = props.tags;
+        this.jsDocTags = props.jsDocTags;
     }
 
     /**
      * @internal
      */
     public static create(
-        props: Omit<ClassProperties<MetadataProperty>, "tags" | "jsDocTags">,
+        props: ClassProperties<MetadataProperty>,
     ): MetadataProperty {
         return new MetadataProperty(props);
     }
@@ -45,14 +43,13 @@ export class MetadataProperty {
         property: IMetadataProperty,
         objects: Map<string, MetadataObject>,
     ) {
-        const obj = this.create({
+        return this.create({
             key: Metadata._From(property.key, objects),
             value: Metadata._From(property.value, objects),
             description: property.description,
+            tags: property.tags.slice(),
+            jsDocTags: property.jsDocTags.slice(),
         });
-        obj.tags.push(...property.tags.slice());
-        obj.jsDocTags.push(...property.jsDocTags.slice());
-        return obj;
     }
 
     public toJSON(): IMetadataProperty {

diff --git a/src/module.ts b/src/module.ts
@@ -84,6 +84,7 @@ export namespace assertType {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const join = $join;
 
     export function predicate(
         matched: boolean,
@@ -227,6 +228,7 @@ export namespace validate {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const join = $join;
 
     export const predicate =
         (res: IValidation) =>
@@ -408,6 +410,7 @@ export namespace equals {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const join = $join;
 }
 
 /**

diff --git a/src/programmers/AssertProgrammer.ts b/src/programmers/AssertProgrammer.ts
@@ -43,9 +43,7 @@ export namespace AssertProgrammer {
                                     equals,
                                     combiner: combine(equals)(importer),
                                     joiner: CheckerProgrammer.DEFAULT_JOINER(
-                                        equals
-                                            ? assert_object(importer)
-                                            : check_object(false)(true),
+                                        assert_object(equals)(importer),
                                     ),
                                 },
                                 modulo,
@@ -66,7 +64,7 @@ const combine =
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner => {
         return (explore: CheckerProgrammer.IExplore) => {
             const combiner = IsProgrammer.CONFIG({
-                object: equals ? assert_object(importer) : undefined,
+                object: assert_object(equals)(importer),
                 numeric: true,
             }).combiner;
             if (explore.tracable === false && explore.from !== "top")
@@ -94,8 +92,8 @@ const combine =
         };
     };
 
-const assert_object = (importer: FunctionImporter) =>
-    check_object(true)(true)((expr) =>
+const assert_object = (equals: boolean) => (importer: FunctionImporter) =>
+    check_object(equals)(true)((expr) =>
         ts.factory.createLogicalOr(
             ts.factory.createStrictEquality(
                 ts.factory.createFalse(),

diff --git a/src/programmers/CheckerProgrammer.ts b/src/programmers/CheckerProgrammer.ts
@@ -69,12 +69,13 @@ export namespace CheckerProgrammer {
         return FeatureProgrammer.generate(
             project,
             CONFIG(project, config, importer),
-            importer.empty() || addition
-                ? () => [
-                      ...importer.declare(modulo),
-                      ...(addition ? addition() : []),
-                  ]
-                : undefined,
+            () =>
+                !importer.empty() || addition
+                    ? [
+                          ...importer.declare(modulo),
+                          ...(addition ? addition() : []),
+                      ]
+                    : undefined,
         );
     }
 

diff --git a/src/programmers/FeatureProgrammer.ts b/src/programmers/FeatureProgrammer.ts
@@ -74,7 +74,9 @@ export namespace FeatureProgrammer {
         (
             project: IProject,
             config: IConfig,
-            addition?: (collection: MetadataCollection) => ts.Statement[],
+            addition: (
+                collection: MetadataCollection,
+            ) => ts.Statement[] | undefined,
         ) =>
         (type: ts.Type) => {
             const [collection, meta] = config.initializer(project, type);
@@ -103,7 +105,7 @@ export namespace FeatureProgrammer {
                     : generate_unioners(config)(collection);
 
             // RETURNS THE OPTIMAL ARROW FUNCTION
-            const added: ts.Statement[] = addition ? addition(collection) : [];
+            const added: ts.Statement[] | undefined = addition(collection);
 
             return ts.factory.createArrowFunction(
                 undefined,
@@ -113,7 +115,7 @@ export namespace FeatureProgrammer {
                 undefined,
                 ts.factory.createBlock(
                     [
-                        ...added,
+                        ...(added || []),
                         ...(functors !== null
                             ? [
                                   ts.factory.createVariableStatement(
@@ -188,30 +190,34 @@ export namespace FeatureProgrammer {
             // REGULAR PROPERTY
             for (const prop of obj.properties) {
                 const key: string | null = prop.key.getSoleLiteral();
-                if (key === null) continue;
-
-                const access = Escaper.variable(key)
-                    ? ts.factory.createPropertyAccessExpression(
-                          ValueFactory.INPUT(),
-                          ts.factory.createIdentifier(key),
-                      )
-                    : ts.factory.createElementAccessExpression(
-                          ValueFactory.INPUT(),
-                          ts.factory.createStringLiteral(key),
-                      );
+                const input: ts.Expression =
+                    key === null
+                        ? ts.factory.createIdentifier("value")
+                        : Escaper.variable(key)
+                        ? ts.factory.createPropertyAccessExpression(
+                              ValueFactory.INPUT(),
+                              ts.factory.createIdentifier(key),
+                          )
+                        : ts.factory.createElementAccessExpression(
+                              ValueFactory.INPUT(),
+                              ts.factory.createStringLiteral(key),
+                          );
 
                 entries.push({
-                    input: access,
+                    input,
                     key: prop.key,
                     meta: prop.value,
                     expression: config.decoder(
-                        access,
+                        input,
                         prop.value,
                         {
                             tracable: config.trace,
                             source: "object",
                             from: "object",
-                            postfix: IdentifierFactory.postfix(key),
+                            postfix:
+                                key !== null
+                                    ? IdentifierFactory.postfix(key)
+                                    : `$join(key)`,
                         },
                         prop.tags,
                     ),

diff --git a/src/programmers/IsProgrammer.ts b/src/programmers/IsProgrammer.ts
@@ -35,7 +35,7 @@ export namespace IsProgrammer {
                         : initial;
             },
             joiner: CheckerProgrammer.DEFAULT_JOINER(
-                options?.object || check_object(false)(true),
+                options?.object || check_object(false)(true)()(),
             ),
         };
     }
@@ -55,23 +55,13 @@ export namespace IsProgrammer {
         equals: boolean = false,
     ) {
         const importer: FunctionImporter = new FunctionImporter();
-        const object = equals
-            ? check_object(equals)(true)((expr) =>
-                  ts.factory.createLogicalOr(
-                      ts.factory.createStrictEquality(
-                          ts.factory.createFalse(),
-                          ts.factory.createIdentifier("exceptionable"),
-                      ),
-                      expr,
-                  ),
-              )()
-            : check_object(false)(true);
+        if (equals === true) importer.use("join");
 
         return CheckerProgrammer.generate(
             project,
             {
                 ...CONFIG({
-                    object,
+                    object: check_object(equals)(true)()(),
                     numeric: true,
                 }),
                 trace: equals,