typia 5.3.12-dev.20240121 → 5.3.12

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -1,157 +1,157 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TemplateFactory } from "../../factories/TemplateFactory";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const stringify_dynamic_properties = (
-  dynamic: IExpressionEntry<ts.Expression>[],
-  regular: string[],
-): ts.Expression => {
-  // BASIC STATMEMENT, CHECK UNDEFINED
-  const statements: ts.Statement[] = [
-    ts.factory.createIfStatement(
-      ts.factory.createStrictEquality(
-        ts.factory.createIdentifier("undefined"),
-        ts.factory.createIdentifier("value"),
-      ),
-      ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-    ),
-  ];
-
-  // PREPARE RETURN FUNCTION
-  const output = () => {
-    const mapped = ts.factory.createCallExpression(
-      IdentifierFactory.access(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("Object.entries"),
-          undefined,
-          [ts.factory.createIdentifier("input")],
-        ),
-      )("map"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [
-            IdentifierFactory.parameter(
-              ts.factory.createArrayBindingPattern([
-                ts.factory.createBindingElement(undefined, undefined, "key"),
-                ts.factory.createBindingElement(undefined, undefined, "value"),
-              ]),
-              ts.factory.createTypeReferenceNode("[string, any]"),
-            ),
-          ],
-          undefined,
-          undefined,
-          ts.factory.createBlock(statements),
-        ),
-      ],
-    );
-    const filtered = ts.factory.createCallExpression(
-      IdentifierFactory.access(mapped)("filter"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [IdentifierFactory.parameter("str")],
-          undefined,
-          undefined,
-          ts.factory.createStrictInequality(
-            ts.factory.createStringLiteral(""),
-            ts.factory.createIdentifier("str"),
-          ),
-        ),
-      ],
-    );
-    return ts.factory.createCallExpression(
-      IdentifierFactory.access(filtered)("join"),
-      undefined,
-      [ts.factory.createStringLiteral(",")],
-    );
-  };
-
-  // WHEN REGULAR PROPERTY EXISTS
-  if (regular.length)
-    statements.push(
-      ts.factory.createIfStatement(
-        ts.factory.createCallExpression(
-          IdentifierFactory.access(
-            ts.factory.createArrayLiteralExpression(
-              regular.map((key) => ts.factory.createStringLiteral(key)),
-            ),
-          )("some"),
-          undefined,
-          [
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              [IdentifierFactory.parameter("regular")],
-              undefined,
-              undefined,
-              ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("regular"),
-                ts.factory.createIdentifier("key"),
-              ),
-            ),
-          ],
-        ),
-        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-      ),
-    );
-
-  // ONLY STRING TYPED KEY EXISTS
-  const simple: boolean =
-    dynamic.length === 1 &&
-    dynamic[0]!.key.size() === 1 &&
-    dynamic[0]!.key.atomics[0]?.type === "string";
-  if (simple === true) {
-    statements.push(stringify(dynamic[0]!));
-    return output();
-  }
-
-  // COMPOSITE TEMPLATE LITERAL TYPES
-  for (const entry of dynamic) {
-    const condition: ts.IfStatement = ts.factory.createIfStatement(
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
-        ),
-        undefined,
-        [ts.factory.createIdentifier("key")],
-      ),
-      stringify(entry),
-    );
-    statements.push(condition);
-  }
-  statements.push(
-    ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-  );
-
-  return output();
-};
-
-/**
- * @internal
- */
-const stringify = (
-  entry: IExpressionEntry<ts.Expression>,
-): ts.ReturnStatement =>
-  ts.factory.createReturnStatement(
-    TemplateFactory.generate([
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier("JSON.stringify"),
-        [],
-        [ts.factory.createIdentifier("key")],
-      ),
-      ts.factory.createStringLiteral(":"),
-      entry.expression,
-    ]),
-  );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const stringify_dynamic_properties = (
+  dynamic: IExpressionEntry<ts.Expression>[],
+  regular: string[],
+): ts.Expression => {
+  // BASIC STATMEMENT, CHECK UNDEFINED
+  const statements: ts.Statement[] = [
+    ts.factory.createIfStatement(
+      ts.factory.createStrictEquality(
+        ts.factory.createIdentifier("undefined"),
+        ts.factory.createIdentifier("value"),
+      ),
+      ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+    ),
+  ];
+
+  // PREPARE RETURN FUNCTION
+  const output = () => {
+    const mapped = ts.factory.createCallExpression(
+      IdentifierFactory.access(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("Object.entries"),
+          undefined,
+          [ts.factory.createIdentifier("input")],
+        ),
+      )("map"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [
+            IdentifierFactory.parameter(
+              ts.factory.createArrayBindingPattern([
+                ts.factory.createBindingElement(undefined, undefined, "key"),
+                ts.factory.createBindingElement(undefined, undefined, "value"),
+              ]),
+              ts.factory.createTypeReferenceNode("[string, any]"),
+            ),
+          ],
+          undefined,
+          undefined,
+          ts.factory.createBlock(statements),
+        ),
+      ],
+    );
+    const filtered = ts.factory.createCallExpression(
+      IdentifierFactory.access(mapped)("filter"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [IdentifierFactory.parameter("str")],
+          undefined,
+          undefined,
+          ts.factory.createStrictInequality(
+            ts.factory.createStringLiteral(""),
+            ts.factory.createIdentifier("str"),
+          ),
+        ),
+      ],
+    );
+    return ts.factory.createCallExpression(
+      IdentifierFactory.access(filtered)("join"),
+      undefined,
+      [ts.factory.createStringLiteral(",")],
+    );
+  };
+
+  // WHEN REGULAR PROPERTY EXISTS
+  if (regular.length)
+    statements.push(
+      ts.factory.createIfStatement(
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(
+            ts.factory.createArrayLiteralExpression(
+              regular.map((key) => ts.factory.createStringLiteral(key)),
+            ),
+          )("some"),
+          undefined,
+          [
+            ts.factory.createArrowFunction(
+              undefined,
+              undefined,
+              [IdentifierFactory.parameter("regular")],
+              undefined,
+              undefined,
+              ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("regular"),
+                ts.factory.createIdentifier("key"),
+              ),
+            ),
+          ],
+        ),
+        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+      ),
+    );
+
+  // ONLY STRING TYPED KEY EXISTS
+  const simple: boolean =
+    dynamic.length === 1 &&
+    dynamic[0]!.key.size() === 1 &&
+    dynamic[0]!.key.atomics[0]?.type === "string";
+  if (simple === true) {
+    statements.push(stringify(dynamic[0]!));
+    return output();
+  }
+
+  // COMPOSITE TEMPLATE LITERAL TYPES
+  for (const entry of dynamic) {
+    const condition: ts.IfStatement = ts.factory.createIfStatement(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(
+          `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+        ),
+        undefined,
+        [ts.factory.createIdentifier("key")],
+      ),
+      stringify(entry),
+    );
+    statements.push(condition);
+  }
+  statements.push(
+    ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+  );
+
+  return output();
+};
+
+/**
+ * @internal
+ */
+const stringify = (
+  entry: IExpressionEntry<ts.Expression>,
+): ts.ReturnStatement =>
+  ts.factory.createReturnStatement(
+    TemplateFactory.generate([
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("JSON.stringify"),
+        [],
+        [ts.factory.createIdentifier("key")],
+      ),
+      ts.factory.createStringLiteral(":"),
+      entry.expression,
+    ]),
+  );

package/src/programmers/internal/stringify_native.ts

@@ -1,7 +1,7 @@
-import ts from "typescript";
-
-/**
- * @internal
- */
-export const stringify_native = (): ts.Expression =>
-  ts.factory.createStringLiteral("{}");
+import ts from "typescript";
+
+/**
+ * @internal
+ */
+export const stringify_native = (): ts.Expression =>
+  ts.factory.createStringLiteral("{}");

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 = (
-  regular: IExpressionEntry<ts.Expression>[],
-  dynamic: IExpressionEntry<ts.Expression>[],
-): ts.Expression[] => {
-  const output: ts.Expression[] = [];
-
-  regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
-  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 !== regular.length - 1 || 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.functional &&
-        entry.meta.nullable === false &&
-        entry.meta.size() === 1);
-
-    if (empty === true) return;
-    else if (
-      entry.meta.isRequired() === false ||
-      entry.meta.functional === true ||
-      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.functional || 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.functional ? 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 = (
+  regular: IExpressionEntry<ts.Expression>[],
+  dynamic: IExpressionEntry<ts.Expression>[],
+): ts.Expression[] => {
+  const output: ts.Expression[] = [];
+
+  regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
+  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 !== regular.length - 1 || 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.functional &&
+        entry.meta.nullable === false &&
+        entry.meta.size() === 1);
+
+    if (empty === true) return;
+    else if (
+      entry.meta.isRequired() === false ||
+      entry.meta.functional === true ||
+      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.functional || 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.functional ? 0 : 1;

package/src/programmers/internal/template_to_pattern.ts

@@ -1,15 +1,15 @@
-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 = (top: boolean) => (template: Metadata[]) => {
-  const pattern: string = template
-    .map((meta) => metadata_to_pattern(false)(meta))
-    .join("");
-  return 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 = (top: boolean) => (template: Metadata[]) => {
+  const pattern: string = template
+    .map((meta) => metadata_to_pattern(false)(meta))
+    .join("");
+  return top ? PatternUtil.fix(pattern) : pattern;
+};

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -1,20 +1,20 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-
-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";
+
+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,49 +1,49 @@
-import { IJsonApplication } from "../../schemas/json/IJsonApplication";
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { application_schema } from "../internal/application_schema";
-
-export namespace JsonApplicationProgrammer {
-  export interface IOptions {
-    purpose: "ajv" | "swagger";
-    surplus: boolean;
-  }
-
-  /**
-   * @internal
-   */
-  export namespace IOptions {
-    export const complement = (options?: Partial<IOptions>): IOptions => ({
-      purpose: options?.purpose ?? "swagger",
-      surplus: options?.surplus ?? false,
-    });
-  }
-
-  export const write =
-    (options?: Partial<IOptions>) =>
-    (metadatas: Array<Metadata>): IJsonApplication => {
-      const fullOptions: IOptions = IOptions.complement(options);
-      const components: IJsonComponents = {
-        schemas: {},
-      };
-      const generator = application_schema(fullOptions)(true)(components);
-
-      return {
-        schemas: metadatas.map((meta, i) => {
-          const schema: IJsonSchema | null = generator(meta)({});
-          if (schema === null)
-            throw new TransformerError({
-              code: "typia.json.application",
-              message: `invalid type on argument - (${meta.getName()}, ${i})`,
-            });
-          return schema;
-        }),
-        components,
-        ...fullOptions,
-      };
-    };
-}
+import { IJsonApplication } from "../../schemas/json/IJsonApplication";
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { application_schema } from "../internal/application_schema";
+
+export namespace JsonApplicationProgrammer {
+  export interface IOptions {
+    purpose: "ajv" | "swagger";
+    surplus: boolean;
+  }
+
+  /**
+   * @internal
+   */
+  export namespace IOptions {
+    export const complement = (options?: Partial<IOptions>): IOptions => ({
+      purpose: options?.purpose ?? "swagger",
+      surplus: options?.surplus ?? false,
+    });
+  }
+
+  export const write =
+    (options?: Partial<IOptions>) =>
+    (metadatas: Array<Metadata>): IJsonApplication => {
+      const fullOptions: IOptions = IOptions.complement(options);
+      const components: IJsonComponents = {
+        schemas: {},
+      };
+      const generator = application_schema(fullOptions)(true)(components);
+
+      return {
+        schemas: metadatas.map((meta, i) => {
+          const schema: IJsonSchema | null = generator(meta)({});
+          if (schema === null)
+            throw new TransformerError({
+              code: "typia.json.application",
+              message: `invalid type on argument - (${meta.getName()}, ${i})`,
+            });
+          return schema;
+        }),
+        components,
+        ...fullOptions,
+      };
+    };
+}