typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/AssertProgrammer.ts

@@ -17,15 +17,14 @@ export namespace AssertProgrammer {
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
     (props: boolean | { equals: boolean; guard: boolean }) =>
-    (type: ts.Type, name?: string) => {
+    (type: ts.Type, name?: string, init?: ts.Expression) => {
       // TO SUPPORT LEGACY FEATURE
       if (typeof props === "boolean") props = { equals: props, guard: false };
 
       const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const is = IsProgrammer.write(project)(modulo, true)(props.equals)(
-        type,
-        name ?? TypeFactory.getFullName(project.checker)(type),
-      );
+      const is: ts.ArrowFunction = IsProgrammer.write(project)(modulo, true)(
+        props.equals,
+      )(type, name ?? TypeFactory.getFullName(project.checker)(type));
       const assert: ts.ArrowFunction = CheckerProgrammer.write(project)({
         prefix: "$a",
         path: true,
@@ -38,59 +37,64 @@ export namespace AssertProgrammer {
             ...(entry.conditions.length === 0
               ? []
               : entry.conditions.length === 1
-              ? entry.conditions[0]!.map((cond) =>
-                  ts.factory.createLogicalOr(
-                    cond.expression,
-                    create_guard_call(importer)(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                ? entry.conditions[0]!.map((cond) =>
+                    ts.factory.createLogicalOr(
+                      cond.expression,
+                      create_guard_call(importer)(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        cond.expected,
+                        input,
                       ),
-                      cond.expected,
-                      input,
                     ),
-                  ),
-                )
-              : [
-                  ts.factory.createLogicalOr(
-                    entry.conditions
-                      .map((set) =>
-                        set
-                          .map((s) => s.expression)
-                          .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                      )
-                      .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                    create_guard_call(importer)(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                  )
+                : [
+                    ts.factory.createLogicalOr(
+                      entry.conditions
+                        .map((set) =>
+                          set
+                            .map((s) => s.expression)
+                            .reduce((a, b) =>
+                              ts.factory.createLogicalAnd(a, b),
+                            ),
+                        )
+                        .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+                      create_guard_call(importer)(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        entry.expected,
+                        input,
                       ),
-                      entry.expected,
-                      input,
                     ),
-                  ),
-                ]),
+                  ]),
           ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
         combiner: combiner(props.equals)(project)(importer),
         joiner: joiner(props.equals)(project)(importer),
         success: ts.factory.createTrue(),
-        addition: () => importer.declare(),
+        addition: () => importer.declare(modulo),
       })(importer)(type, name);
 
       return ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          Guardian.parameter(init),
+        ],
         props.guard
           ? ts.factory.createTypePredicateNode(
               ts.factory.createToken(ts.SyntaxKind.AssertsKeyword),
@@ -276,7 +280,7 @@ export namespace AssertProgrammer {
       expected: string,
       value: ts.Expression,
     ): ts.Expression =>
-      ts.factory.createCallExpression(importer.use("guard", true), undefined, [
+      ts.factory.createCallExpression(importer.use("guard"), undefined, [
         exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
         ts.factory.createObjectLiteralExpression(
           [
@@ -289,5 +293,45 @@ export namespace AssertProgrammer {
           ],
           true,
         ),
+        Guardian.identifier(),
       ]);
+
+  export namespace Guardian {
+    export const identifier = () => ts.factory.createIdentifier("errorFactory");
+    export const parameter = (init: ts.Expression | undefined) =>
+      IdentifierFactory.parameter(
+        "errorFactory",
+        type(),
+        init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+      );
+    export const type = () =>
+      ts.factory.createFunctionTypeNode(
+        undefined,
+        [
+          ts.factory.createParameterDeclaration(
+            undefined,
+            undefined,
+            ts.factory.createIdentifier("p"),
+            undefined,
+            ts.factory.createImportTypeNode(
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("typia"),
+              ),
+              undefined,
+              ts.factory.createQualifiedName(
+                ts.factory.createIdentifier("TypeGuardError"),
+                ts.factory.createIdentifier("IProps"),
+              ),
+              undefined,
+              false,
+            ),
+            undefined,
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          ts.factory.createIdentifier("Error"),
+          undefined,
+        ),
+      );
+  }
 }

package/src/programmers/CheckerProgrammer.ts

@@ -18,6 +18,7 @@ import { IProject } from "../transformers/IProject";
 import { TransformerError } from "../transformers/TransformerError";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
 import { AtomicPredicator } from "./helpers/AtomicPredicator";
 import { FunctionImporter } from "./helpers/FunctionImporter";
 import { ICheckEntry } from "./helpers/ICheckEntry";
@@ -335,7 +336,30 @@ export namespace CheckerProgrammer {
       // CONSTANT VALUES
       for (const constant of meta.constants)
         if (AtomicPredicator.constant(meta)(constant.type))
-          for (const val of constant.values) add(true, getConstantValue(val));
+          for (const v of constant.values) add(true, getConstantValue(v.value));
+      if (meta.escaped !== null)
+        binaries.push({
+          combined: false,
+          expression:
+            meta.escaped.original.size() === 1 &&
+            meta.escaped.original.natives.length === 1
+              ? check_native(meta.escaped.original.natives[0]!)(input)
+              : ts.factory.createLogicalAnd(
+                  decode(project)(config)(importer)(
+                    input,
+                    meta.escaped.original,
+                    explore,
+                  ),
+                  ts.factory.createLogicalAnd(
+                    IsProgrammer.decode_to_json(false)(input),
+                    decode_escaped(project)(config)(importer)(
+                      input,
+                      meta.escaped.returns,
+                      explore,
+                    ),
+                  ),
+                ),
+        });
 
       // ATOMIC VALUES
       for (const atom of meta.atomics)
@@ -572,8 +596,8 @@ export namespace CheckerProgrammer {
             meta.getName(),
           )
         : binaries.length
-        ? config.combiner(explore)("or")(input, binaries, meta.getName())
-        : config.success;
+          ? config.combiner(explore)("or")(input, binaries, meta.getName())
+          : config.success;
     };
 
   export const decode_object =
@@ -778,6 +802,36 @@ export namespace CheckerProgrammer {
       );
     };
 
+  const decode_escaped =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, meta: Metadata, explore: IExplore): ts.Expression =>
+      ts.factory.createCallExpression(
+        ts.factory.createParenthesizedExpression(
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+            undefined,
+            undefined,
+            decode(project)(config)(importer)(
+              ts.factory.createIdentifier("input"),
+              meta,
+              explore,
+            ),
+          ),
+        ),
+        undefined,
+        [
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(input)("toJSON"),
+            undefined,
+            [],
+          ),
+        ],
+      );
+
   /* -----------------------------------------------------------
         UNION TYPE EXPLORERS
     ----------------------------------------------------------- */

package/src/programmers/FeatureProgrammer.ts

@@ -406,33 +406,33 @@ export namespace FeatureProgrammer {
         config.path === false && config.trace === false
           ? []
           : config.path === true && config.trace === true
-          ? [
-              ts.factory.createIdentifier(
-                explore.postfix ? `_path + ${explore.postfix}` : "_path",
-              ),
-              explore.source === "function"
-                ? ts.factory.createIdentifier(
-                    `${explore.tracable} && _exceptionable`,
-                  )
-                : explore.tracable
-                ? ts.factory.createTrue()
-                : ts.factory.createFalse(),
-            ]
-          : config.path === true
-          ? [
-              ts.factory.createIdentifier(
-                explore.postfix ? `_path + ${explore.postfix}` : "_path",
-              ),
-            ]
-          : [
-              explore.source === "function"
-                ? ts.factory.createIdentifier(
-                    `${explore.tracable} && _exceptionable`,
-                  )
-                : explore.tracable
-                ? ts.factory.createTrue()
-                : ts.factory.createFalse(),
-            ];
+            ? [
+                ts.factory.createIdentifier(
+                  explore.postfix ? `_path + ${explore.postfix}` : "_path",
+                ),
+                explore.source === "function"
+                  ? ts.factory.createIdentifier(
+                      `${explore.tracable} && _exceptionable`,
+                    )
+                  : explore.tracable
+                    ? ts.factory.createTrue()
+                    : ts.factory.createFalse(),
+              ]
+            : config.path === true
+              ? [
+                  ts.factory.createIdentifier(
+                    explore.postfix ? `_path + ${explore.postfix}` : "_path",
+                  ),
+                ]
+              : [
+                  explore.source === "function"
+                    ? ts.factory.createIdentifier(
+                        `${explore.tracable} && _exceptionable`,
+                      )
+                    : explore.tracable
+                      ? ts.factory.createTrue()
+                      : ts.factory.createFalse(),
+                ];
       return (input: ts.Expression) => [input, ...tail];
     };
 

package/src/programmers/IsProgrammer.ts

@@ -122,7 +122,7 @@ export namespace IsProgrammer {
           numeric: OptionPredicator.numeric(project.options),
         })(project)(importer),
         trace: equals,
-        addition: () => importer.declare(),
+        addition: () => importer.declare(modulo),
       };
 
       config.decoder = () => (input, target, explore) => {

package/src/programmers/RandomProgrammer.ts

@@ -21,6 +21,7 @@ import { TransformerError } from "../transformers/TransformerError";
 
 import { Escaper } from "../utils/Escaper";
 
+import { Format } from "../tags";
 import { FunctionImporter } from "./helpers/FunctionImporter";
 import { RandomJoiner } from "./helpers/RandomJoiner";
 import { RandomRanger } from "./helpers/RandomRanger";
@@ -80,15 +81,23 @@ export namespace RandomProgrammer {
               init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
             ),
           ],
-          ts.factory.createTypeReferenceNode(
-            `typia.Resolved<${
-              name ?? TypeFactory.getFullName(project.checker)(type)
-            }>`,
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(project.checker)(type),
+              ),
+            ],
+            false,
           ),
           undefined,
           ts.factory.createBlock(
             [
-              ...importer.declare(),
+              ...importer.declare(modulo),
               ...functions.objects,
               ...functions.arrays,
               ...functions.tuples,
@@ -230,7 +239,7 @@ export namespace RandomProgrammer {
 
       // CONSTANT TYPES
       for (const constant of meta.constants)
-        for (const value of constant.values)
+        for (const { value } of constant.values)
           expressions.push(decode_atomic(value));
 
       // ATOMIC VARIABLES
@@ -265,7 +274,7 @@ export namespace RandomProgrammer {
       // PICK UP A TYPE
       if (expressions.length === 1) return expressions[0]!;
       return ts.factory.createCallExpression(
-        ts.factory.createCallExpression(COALESCE(importer)("pick"), undefined, [
+        ts.factory.createCallExpression(importer.use("pick"), undefined, [
           ts.factory.createArrayLiteralExpression(
             expressions.map((expr) =>
               ts.factory.createArrowFunction(
@@ -296,10 +305,10 @@ export namespace RandomProgrammer {
     typeof value === "boolean"
       ? ts.factory.createIdentifier(value.toString())
       : typeof value === "number"
-      ? ExpressionFactory.number(value)
-      : typeof value === "string"
-      ? ts.factory.createStringLiteral(value)
-      : ExpressionFactory.bigint(Number(value));
+        ? ExpressionFactory.number(value)
+        : typeof value === "string"
+          ? ts.factory.createStringLiteral(value)
+          : ExpressionFactory.bigint(Number(value));
 
   const decode_template =
     (importer: FunctionImporter) =>
@@ -319,12 +328,12 @@ export namespace RandomProgrammer {
         )
           ? "int"
           : tags.find(
-              (t) =>
-                t.kind === "type" &&
-                (t.value === "uint32" || t.value === "uint64"),
-            )
-          ? "uint"
-          : "double";
+                (t) =>
+                  t.kind === "type" &&
+                  (t.value === "uint32" || t.value === "uint64"),
+              )
+            ? "uint"
+            : "double";
         const multiply = tags.find((t) => t.kind === "multipleOf");
         return random_custom(COALESCE(importer))("number")(tags)(
           RandomRanger.number({
@@ -383,9 +392,7 @@ export namespace RandomProgrammer {
             for (const t of tags)
               if (t.kind === "format")
                 return ts.factory.createCallExpression(
-                  COALESCE(importer)(
-                    t.value === "date-time" ? "datetime" : t.value,
-                  ),
+                  COALESCE(importer)(emendFormat(t.value)),
                   undefined,
                   undefined,
                 );
@@ -621,6 +628,8 @@ export namespace RandomProgrammer {
       else if (type === "ArrayBuffer" || type === "SharedArrayBuffer")
         return decode_native_array_buffer(importer)(type);
       else if (type === "DataView") return decode_native_data_view(importer);
+      else if (type === "Blob") return decode_native_blob(importer);
+      else if (type === "File") return decode_native_file(importer);
       else
         return ts.factory.createNewExpression(
           ts.factory.createIdentifier(type),
@@ -697,8 +706,8 @@ export namespace RandomProgrammer {
                     type === "Float32Array" || type === "Float64Array"
                       ? "number"
                       : type === "BigInt64Array" || type === "BigUint64Array"
-                      ? "bigint"
-                      : "integer",
+                        ? "bigint"
+                        : "integer",
                   ),
                   undefined,
                   [literal(minimum), literal(maximum)],
@@ -710,6 +719,48 @@ export namespace RandomProgrammer {
       );
     };
 
+  const decode_native_blob = (importer: FunctionImporter) =>
+    ts.factory.createNewExpression(
+      ts.factory.createIdentifier("Blob"),
+      undefined,
+      [
+        ts.factory.createArrayLiteralExpression(
+          [decode_native_byte_array(importer)("Uint8Array")],
+          true,
+        ),
+      ],
+    );
+
+  const decode_native_file = (importer: FunctionImporter) =>
+    ts.factory.createNewExpression(
+      ts.factory.createIdentifier("File"),
+      undefined,
+      [
+        ts.factory.createArrayLiteralExpression(
+          [decode_native_byte_array(importer)("Uint8Array")],
+          true,
+        ),
+        ts.factory.createTemplateExpression(ts.factory.createTemplateHead(""), [
+          ts.factory.createTemplateSpan(
+            ts.factory.createCallExpression(
+              COALESCE(importer)("string"),
+              undefined,
+              [ts.factory.createNumericLiteral(8)],
+            ),
+            ts.factory.createTemplateMiddle("."),
+          ),
+          ts.factory.createTemplateSpan(
+            ts.factory.createCallExpression(
+              COALESCE(importer)("string"),
+              undefined,
+              [ts.factory.createNumericLiteral(3)],
+            ),
+            ts.factory.createTemplateTail(""),
+          ),
+        ]),
+      ],
+    );
+
   const decode_native_array_buffer =
     (importer: FunctionImporter) =>
     (type: "ArrayBuffer" | "SharedArrayBuffer"): ts.Expression =>
@@ -823,3 +874,15 @@ const COALESCE = (importer: FunctionImporter) => (name: string) =>
           ts.factory.createStringLiteral(name),
         ),
   )(IdentifierFactory.access(importer.use("generator"))(name));
+
+const emendFormat = (key: keyof Format.Validator) =>
+  key === "date-time"
+    ? "datetime"
+    : key
+        .split("-")
+        .map((str, i) =>
+          i === 0 || str.length === 0
+            ? str
+            : str[0]!.toUpperCase() + str.substring(1),
+        )
+        .join("");

package/src/programmers/TypiaProgrammer.ts

@@ -68,7 +68,9 @@ export namespace TypiaProgrammer {
         transform(
           program,
           ((compilerOptions.plugins as any[]) ?? []).find(
-            (p: any) => p.transform === "typia/lib/transform",
+            (p: any) =>
+              p.transform === "typia/lib/transform" ||
+              p.transform === "../src/transform.ts",
           ) ?? {},
           {
             addDiagnostic: (diag) => diagnostics.push(diag),
@@ -87,12 +89,12 @@ export namespace TypiaProgrammer {
         diag.category === ts.DiagnosticCategory.Warning
           ? "warning"
           : diag.category === ts.DiagnosticCategory.Error
-          ? "error"
-          : diag.category === ts.DiagnosticCategory.Suggestion
-          ? "suggestion"
-          : diag.category === ts.DiagnosticCategory.Message
-          ? "message"
-          : "unkown";
+            ? "error"
+            : diag.category === ts.DiagnosticCategory.Suggestion
+              ? "suggestion"
+              : diag.category === ts.DiagnosticCategory.Message
+                ? "message"
+                : "unkown";
       const [line, pos] = diag.file
         ? (() => {
             const lines: string[] = diag
@@ -118,20 +120,10 @@ export namespace TypiaProgrammer {
         .replace(props.input, props.output);
 
       const content: string = printer.printFile(file);
-      await fs.promises.writeFile(to, emend(content), "utf8");
+      await fs.promises.writeFile(to, content, "utf8");
     }
   };
 
-  const emend = (content: string): string => {
-    if (
-      content.indexOf("typia.") === -1 ||
-      content.indexOf("import typia") !== -1 ||
-      content.indexOf("import * as typia") !== -1
-    )
-      return content;
-    return `import typia from "typia";\n\n${content}`;
-  };
-
   const is_directory = async (current: string): Promise<boolean> => {
     const stat: fs.Stats = await fs.promises.stat(current);
     return stat.isDirectory();