typia 7.0.0-dev.20241005 → 7.0.0-dev.20241008

package/src/programmers/internal/stringify_regular_properties.ts

@@ -1,81 +1,81 @@
-import ts from "typescript";
-
-import { TemplateFactory } from "../../factories/TemplateFactory";
-import { ValueFactory } from "../../factories/ValueFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-
-/**
- * @internal
- */
-export const stringify_regular_properties = (props: {
-  regular: IExpressionEntry<ts.Expression>[];
-  dynamic: IExpressionEntry<ts.Expression>[];
-}): ts.Expression[] => {
-  const output: ts.Expression[] = [];
-
-  props.regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
-  props.regular.forEach((entry, index) => {
-    // BASE ELEMENTS
-    const key: string = entry.key.getSoleLiteral()!;
-    const base: ts.Expression[] = [
-      ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
-      entry.expression,
-    ];
-    if (index !== props.regular.length - 1 || props.dynamic.length !== 0)
-      base.push(ts.factory.createStringLiteral(`,`));
-
-    const empty: boolean =
-      (entry.meta.isRequired() === false &&
-        entry.meta.nullable === false &&
-        entry.meta.size() === 0) ||
-      (!!entry.meta.functions.length &&
-        entry.meta.nullable === false &&
-        entry.meta.size() === 1);
-
-    if (empty === true) return;
-    else if (
-      entry.meta.isRequired() === false ||
-      entry.meta.functions.length ||
-      entry.meta.any === true
-    )
-      output.push(
-        ts.factory.createConditionalExpression(
-          (() => {
-            const conditions: ts.BinaryExpression[] = [];
-            if (entry.meta.isRequired() === false || entry.meta.any)
-              conditions.push(
-                ts.factory.createStrictEquality(
-                  ts.factory.createIdentifier("undefined"),
-                  entry.input,
-                ),
-              );
-            if (entry.meta.functions.length || entry.meta.any)
-              conditions.push(
-                ts.factory.createStrictEquality(
-                  ts.factory.createStringLiteral("function"),
-                  ValueFactory.TYPEOF(entry.input),
-                ),
-              );
-            return conditions.length === 1
-              ? conditions[0]!
-              : conditions.reduce((x, y) => ts.factory.createLogicalOr(x, y));
-          })(),
-          undefined,
-          ts.factory.createStringLiteral(""),
-          undefined,
-          TemplateFactory.generate(base),
-        ),
-      );
-    else output.push(...base);
-  });
-  return output;
-};
-
-/**
- * @internal
- */
-const sequence = (meta: Metadata): number =>
-  meta.any || !meta.isRequired() || meta.functions.length ? 0 : 1;
+import ts from "typescript";
+
+import { TemplateFactory } from "../../factories/TemplateFactory";
+import { ValueFactory } from "../../factories/ValueFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+
+/**
+ * @internal
+ */
+export const stringify_regular_properties = (props: {
+  regular: IExpressionEntry<ts.Expression>[];
+  dynamic: IExpressionEntry<ts.Expression>[];
+}): ts.Expression[] => {
+  const output: ts.Expression[] = [];
+
+  props.regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
+  props.regular.forEach((entry, index) => {
+    // BASE ELEMENTS
+    const key: string = entry.key.getSoleLiteral()!;
+    const base: ts.Expression[] = [
+      ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
+      entry.expression,
+    ];
+    if (index !== props.regular.length - 1 || props.dynamic.length !== 0)
+      base.push(ts.factory.createStringLiteral(`,`));
+
+    const empty: boolean =
+      (entry.meta.isRequired() === false &&
+        entry.meta.nullable === false &&
+        entry.meta.size() === 0) ||
+      (!!entry.meta.functions.length &&
+        entry.meta.nullable === false &&
+        entry.meta.size() === 1);
+
+    if (empty === true) return;
+    else if (
+      entry.meta.isRequired() === false ||
+      entry.meta.functions.length ||
+      entry.meta.any === true
+    )
+      output.push(
+        ts.factory.createConditionalExpression(
+          (() => {
+            const conditions: ts.BinaryExpression[] = [];
+            if (entry.meta.isRequired() === false || entry.meta.any)
+              conditions.push(
+                ts.factory.createStrictEquality(
+                  ts.factory.createIdentifier("undefined"),
+                  entry.input,
+                ),
+              );
+            if (entry.meta.functions.length || entry.meta.any)
+              conditions.push(
+                ts.factory.createStrictEquality(
+                  ts.factory.createStringLiteral("function"),
+                  ValueFactory.TYPEOF(entry.input),
+                ),
+              );
+            return conditions.length === 1
+              ? conditions[0]!
+              : conditions.reduce((x, y) => ts.factory.createLogicalOr(x, y));
+          })(),
+          undefined,
+          ts.factory.createStringLiteral(""),
+          undefined,
+          TemplateFactory.generate(base),
+        ),
+      );
+    else output.push(...base);
+  });
+  return output;
+};
+
+/**
+ * @internal
+ */
+const sequence = (meta: Metadata): number =>
+  meta.any || !meta.isRequired() || meta.functions.length ? 0 : 1;

package/src/programmers/internal/template_to_pattern.ts

@@ -1,23 +1,23 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const template_to_pattern = (props: {
-  top: boolean;
-  template: Metadata[];
-}) => {
-  const pattern: string = props.template
-    .map((meta) =>
-      metadata_to_pattern({
-        top: false,
-        metadata: meta,
-      }),
-    )
-    .join("");
-  return props.top ? PatternUtil.fix(pattern) : pattern;
-};
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const template_to_pattern = (props: {
+  top: boolean;
+  template: Metadata[];
+}) => {
+  const pattern: string = props.template
+    .map((meta) =>
+      metadata_to_pattern({
+        top: false,
+        metadata: meta,
+      }),
+    )
+    .join("");
+  return props.top ? PatternUtil.fix(pattern) : pattern;
+};

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -1,23 +1,23 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-
-/**
- * @internal
- */
-export const wrap_metadata_rest_tuple = (rest: Metadata) => {
-  const wrapper: Metadata = Metadata.initialize();
-  wrapper.arrays.push(
-    MetadataArray.create({
-      type: MetadataArrayType.create({
-        name: `...${rest.getName()}`,
-        value: rest,
-        nullables: [],
-        recursive: false,
-        index: null,
-      }),
-      tags: [],
-    }),
-  );
-  return wrapper;
-};
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+
+/**
+ * @internal
+ */
+export const wrap_metadata_rest_tuple = (rest: Metadata) => {
+  const wrapper: Metadata = Metadata.initialize();
+  wrapper.arrays.push(
+    MetadataArray.create({
+      type: MetadataArrayType.create({
+        name: `...${rest.getName()}`,
+        value: rest,
+        nullables: [],
+        recursive: false,
+        index: null,
+      }),
+      tags: [],
+    }),
+  );
+  return wrapper;
+};

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -48,15 +48,15 @@ export namespace JsonAssertParseProgrammer {
         undefined,
         [
           IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
-          AssertProgrammer.Guardian.parameter(props.init),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
         ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Primitive"),
-          [
+        props.context.importer.type({
+          file: "typia",
+          name: "Primitive",
+          arguments: [
             ts.factory.createTypeReferenceNode(
               props.name ??
                 TypeFactory.getFullName({
@@ -65,8 +65,7 @@ export namespace JsonAssertParseProgrammer {
                 }),
             ),
           ],
-          false,
-        ),
+        }),
         undefined,
         ts.factory.createCallExpression(
           ts.factory.createIdentifier("__assert"),

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -62,7 +62,10 @@ export namespace JsonAssertStringifyProgrammer {
         undefined,
         [
           IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
         ],
         stringify.arrow.type,
         undefined,

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -46,13 +46,10 @@ export namespace JsonIsParseProgrammer {
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
         ts.factory.createUnionTypeNode([
-          ts.factory.createImportTypeNode(
-            ts.factory.createLiteralTypeNode(
-              ts.factory.createStringLiteral("typia"),
-            ),
-            undefined,
-            ts.factory.createIdentifier("Primitive"),
-            [
+          props.context.importer.type({
+            file: "typia",
+            name: "Primitive",
+            arguments: [
               ts.factory.createTypeReferenceNode(
                 props.name ??
                   TypeFactory.getFullName({
@@ -61,8 +58,7 @@ export namespace JsonIsParseProgrammer {
                   }),
               ),
             ],
-            false,
-          ),
+          }),
           ts.factory.createTypeReferenceNode("null"),
         ]),
         undefined,

package/src/programmers/json/JsonValidateParseProgrammer.ts

@@ -47,15 +47,25 @@ export namespace JsonValidateParseProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.IValidation<typia.Primitive<${
-            props.name ??
-            TypeFactory.getFullName({
-              checker: props.context.checker,
-              type: props.type,
-            })
-          }>>`,
-        ),
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [
+            props.context.importer.type({
+              file: "typia",
+              name: "Primitive",
+              arguments: [
+                ts.factory.createTypeReferenceNode(
+                  props.name ??
+                    TypeFactory.getFullName({
+                      checker: props.context.checker,
+                      type: props.type,
+                    }),
+                ),
+              ],
+            }),
+          ],
+        }),
         undefined,
         ts.factory.createAsExpression(
           ts.factory.createCallExpression(

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -61,9 +61,14 @@ export namespace JsonValidateStringifyProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          stringify.arrow.type ?? ts.factory.createTypeReferenceNode("string"),
-        ]),
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [
+            stringify.arrow.type ??
+              ts.factory.createTypeReferenceNode("string"),
+          ],
+        }),
         undefined,
         ts.factory.createBlock([
           StatementFactory.constant({