typia 7.0.0-dev.20241005 → 7.0.0-dev.20241007

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/JsonApplicationProgrammer.ts

@@ -1,92 +1,92 @@
-import { OpenApi, OpenApiV3 } from "@samchon/openapi";
-
-import { IJsonApplication } from "../../schemas/json/IJsonApplication";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { application_v30_schema } from "../internal/application_v30_schema";
-import { application_v31_schema } from "../internal/application_v31_schema";
-
-export namespace JsonApplicationProgrammer {
-  export const validate = (meta: Metadata): string[] => {
-    const output: string[] = [];
-    if (
-      meta.atomics.some((a) => a.type === "bigint") ||
-      meta.constants.some((c) => c.type === "bigint")
-    )
-      output.push("JSON schema does not support bigint type.");
-    if (
-      meta.tuples.some((t) =>
-        t.type.elements.some((e) => e.isRequired() === false),
-      ) ||
-      meta.arrays.some((a) => a.type.value.isRequired() === false)
-    )
-      output.push("JSON schema does not support undefined type in array.");
-    if (meta.maps.length) output.push("JSON schema does not support Map type.");
-    if (meta.sets.length) output.push("JSON schema does not support Set type.");
-    for (const native of meta.natives)
-      if (
-        AtomicPredicator.native(native) === false &&
-        native !== "Date" &&
-        native !== "Blob" &&
-        native !== "File"
-      )
-        output.push(`JSON schema does not support ${native} type.`);
-    return output;
-  };
-
-  export const write = <Version extends "3.0" | "3.1">(version: Version) =>
-    version === "3.0" ? v30 : v31;
-
-  const v30 = (metadatas: Array<Metadata>): IJsonApplication<"3.0"> => {
-    const components: OpenApiV3.IComponents = {};
-    const generator = (meta: Metadata): OpenApiV3.IJsonSchema | null =>
-      application_v30_schema({
-        blockNever: true,
-        components,
-        attribute: {},
-        metadata: meta,
-      });
-    return {
-      version: "3.0",
-      components,
-      schemas: metadatas.map((meta, i) => {
-        const schema: OpenApiV3.IJsonSchema | null = generator(meta);
-        if (schema === null)
-          throw new TransformerError({
-            code: "typia.json.application",
-            message: `invalid type on argument - (${meta.getName()}, ${i})`,
-          });
-        return schema;
-      }),
-    };
-  };
-
-  const v31 = (metadatas: Array<Metadata>): IJsonApplication<"3.1"> => {
-    const components: OpenApi.IComponents = {
-      schemas: {},
-    };
-    const generator = (meta: Metadata): OpenApi.IJsonSchema | null =>
-      application_v31_schema({
-        blockNever: true,
-        components,
-        attribute: {},
-        metadata: meta,
-      });
-    return {
-      version: "3.1",
-      components,
-      schemas: metadatas.map((meta, i) => {
-        const schema: OpenApi.IJsonSchema | null = generator(meta);
-        if (schema === null)
-          throw new TransformerError({
-            code: "typia.json.application",
-            message: `invalid type on argument - (${meta.getName()}, ${i})`,
-          });
-        return schema;
-      }),
-    };
-  };
-}
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { IJsonApplication } from "../../schemas/json/IJsonApplication";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { application_v30_schema } from "../internal/application_v30_schema";
+import { application_v31_schema } from "../internal/application_v31_schema";
+
+export namespace JsonApplicationProgrammer {
+  export const validate = (meta: Metadata): string[] => {
+    const output: string[] = [];
+    if (
+      meta.atomics.some((a) => a.type === "bigint") ||
+      meta.constants.some((c) => c.type === "bigint")
+    )
+      output.push("JSON schema does not support bigint type.");
+    if (
+      meta.tuples.some((t) =>
+        t.type.elements.some((e) => e.isRequired() === false),
+      ) ||
+      meta.arrays.some((a) => a.type.value.isRequired() === false)
+    )
+      output.push("JSON schema does not support undefined type in array.");
+    if (meta.maps.length) output.push("JSON schema does not support Map type.");
+    if (meta.sets.length) output.push("JSON schema does not support Set type.");
+    for (const native of meta.natives)
+      if (
+        AtomicPredicator.native(native) === false &&
+        native !== "Date" &&
+        native !== "Blob" &&
+        native !== "File"
+      )
+        output.push(`JSON schema does not support ${native} type.`);
+    return output;
+  };
+
+  export const write = <Version extends "3.0" | "3.1">(version: Version) =>
+    version === "3.0" ? v30 : v31;
+
+  const v30 = (metadatas: Array<Metadata>): IJsonApplication<"3.0"> => {
+    const components: OpenApiV3.IComponents = {};
+    const generator = (meta: Metadata): OpenApiV3.IJsonSchema | null =>
+      application_v30_schema({
+        blockNever: true,
+        components,
+        attribute: {},
+        metadata: meta,
+      });
+    return {
+      version: "3.0",
+      components,
+      schemas: metadatas.map((meta, i) => {
+        const schema: OpenApiV3.IJsonSchema | null = generator(meta);
+        if (schema === null)
+          throw new TransformerError({
+            code: "typia.json.application",
+            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+          });
+        return schema;
+      }),
+    };
+  };
+
+  const v31 = (metadatas: Array<Metadata>): IJsonApplication<"3.1"> => {
+    const components: OpenApi.IComponents = {
+      schemas: {},
+    };
+    const generator = (meta: Metadata): OpenApi.IJsonSchema | null =>
+      application_v31_schema({
+        blockNever: true,
+        components,
+        attribute: {},
+        metadata: meta,
+      });
+    return {
+      version: "3.1",
+      components,
+      schemas: metadatas.map((meta, i) => {
+        const schema: OpenApi.IJsonSchema | null = generator(meta);
+        if (schema === null)
+          throw new TransformerError({
+            code: "typia.json.application",
+            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+          });
+        return schema;
+      }),
+    };
+  };
+}

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,104 +1,104 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-
-export namespace JsonAssertParseProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-    init: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      config: {
-        equals: false,
-        guard: false,
-      },
-    });
-    return {
-      functions: assert.functions,
-      statements: [
-        ...assert.statements,
-        StatementFactory.constant({
-          name: "__assert",
-          value: assert.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
-          AssertProgrammer.Guardian.parameter(props.init),
-        ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Primitive"),
-          [
-            ts.factory.createTypeReferenceNode(
-              props.name ??
-                TypeFactory.getFullName({
-                  checker: props.context.checker,
-                  type: props.type,
-                }),
-            ),
-          ],
-          false,
-        ),
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__assert"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("JSON.parse"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            AssertProgrammer.Guardian.identifier(),
-          ],
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      context: props.context,
-      functor,
-      type: props.type,
-      name: props.name,
-      init: props.init,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+
+export namespace JsonAssertParseProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+    init: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      config: {
+        equals: false,
+        guard: false,
+      },
+    });
+    return {
+      functions: assert.functions,
+      statements: [
+        ...assert.statements,
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
+          AssertProgrammer.Guardian.parameter(props.init),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Primitive"),
+          [
+            ts.factory.createTypeReferenceNode(
+              props.name ??
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
+            ),
+          ],
+          false,
+        ),
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__assert"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("JSON.parse"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            AssertProgrammer.Guardian.identifier(),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      context: props.context,
+      functor,
+      type: props.type,
+      name: props.name,
+      init: props.init,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}