typia 6.10.2-dev.20240920 → 6.10.2

package/src/programmers/internal/llm_schema_tuple.ts

@@ -1,31 +1,31 @@
-import { ILlmSchema } from "@samchon/openapi";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
-
-import { llm_schema_station } from "./llm_schema_station";
-
-/**
- * @internal
- */
-export const llm_schema_tuple = (props: {
-  tuple: MetadataTuple;
-  attribute: ILlmSchema.__IAttribute;
-}): ILlmSchema.IArray => ({
-  ...props.attribute,
-  type: "array",
-  items: llm_schema_station({
-    blockNever: false,
-    attribute: props.attribute,
-    metadata: props.tuple.type.elements.reduce(
-      (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
-      Metadata.initialize(),
-    ),
-  }),
-  minItems: !!props.tuple.type.elements.at(-1)?.rest
-    ? props.tuple.type.elements.length - 1
-    : props.tuple.type.elements.filter((x) => !x.optional).length,
-  maxItems: !!props.tuple.type.elements.at(-1)?.rest
-    ? undefined!
-    : props.tuple.type.elements.length,
-});
+import { ILlmSchema } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+
+import { llm_schema_station } from "./llm_schema_station";
+
+/**
+ * @internal
+ */
+export const llm_schema_tuple = (props: {
+  tuple: MetadataTuple;
+  attribute: ILlmSchema.__IAttribute;
+}): ILlmSchema.IArray => ({
+  ...props.attribute,
+  type: "array",
+  items: llm_schema_station({
+    blockNever: false,
+    attribute: props.attribute,
+    metadata: props.tuple.type.elements.reduce(
+      (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
+      Metadata.initialize(),
+    ),
+  }),
+  minItems: !!props.tuple.type.elements.at(-1)?.rest
+    ? props.tuple.type.elements.length - 1
+    : props.tuple.type.elements.filter((x) => !x.optional).length,
+  maxItems: !!props.tuple.type.elements.at(-1)?.rest
+    ? undefined!
+    : props.tuple.type.elements.length,
+});

package/src/programmers/internal/metadata_to_pattern.ts

@@ -1,34 +1,34 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const metadata_to_pattern =
-  (top: boolean) =>
-  (meta: Metadata): string => {
-    if (meta.atomics.find((a) => a.type === "string") !== undefined)
-      return "(.*)";
-
-    const values: string[] = meta.constants
-      .map((c) => {
-        if (c.type !== "string") return c.values.map((v) => v.toString());
-        return (c.values.map((v) => v.value) as string[]).map((str) =>
-          PatternUtil.escape(str),
-        );
-      })
-      .flat();
-    for (const a of meta.atomics)
-      if (a.type === "number" || a.type === "bigint")
-        values.push(PatternUtil.NUMBER);
-      else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
-    for (const { row } of meta.templates)
-      values.push("(" + template_to_pattern(false)(row) + ")");
-
-    const pattern: string =
-      values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
-    return top ? PatternUtil.fix(pattern) : pattern;
-  };
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const metadata_to_pattern =
+  (top: boolean) =>
+  (meta: Metadata): string => {
+    if (meta.atomics.find((a) => a.type === "string") !== undefined)
+      return "(.*)";
+
+    const values: string[] = meta.constants
+      .map((c) => {
+        if (c.type !== "string") return c.values.map((v) => v.toString());
+        return (c.values.map((v) => v.value) as string[]).map((str) =>
+          PatternUtil.escape(str),
+        );
+      })
+      .flat();
+    for (const a of meta.atomics)
+      if (a.type === "number" || a.type === "bigint")
+        values.push(PatternUtil.NUMBER);
+      else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
+    for (const { row } of meta.templates)
+      values.push("(" + template_to_pattern(false)(row) + ")");
+
+    const pattern: string =
+      values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+    return top ? PatternUtil.fix(pattern) : pattern;
+  };

package/src/programmers/internal/postfix_of_tuple.ts

@@ -1,2 +1,2 @@
-export const postfix_of_tuple = (str: string): string =>
-  str.endsWith('"') ? str.slice(0, -1) : `${str} + "`;
+export const postfix_of_tuple = (str: string): string =>
+  str.endsWith('"') ? str.slice(0, -1) : `${str} + "`;

package/src/programmers/internal/prune_object_properties.ts

@@ -1,60 +1,60 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const prune_object_properties = (obj: MetadataObject) => {
-  const input: ts.Expression = ts.factory.createIdentifier("input");
-  const key: ts.Expression = ts.factory.createIdentifier("key");
-
-  const condition: ts.Expression[] = obj.properties.map((prop) => {
-    const name: string | null = prop.key.getSoleLiteral();
-    if (name !== null)
-      return ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral(name),
-        ts.factory.createIdentifier("key"),
-      );
-    return ts.factory.createCallExpression(
-      ts.factory.createIdentifier(
-        `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
-      ),
-      undefined,
-      [key],
-    );
-  });
-
-  const statements: ts.Statement[] = [];
-  if (condition.length)
-    statements.push(
-      ts.factory.createIfStatement(
-        condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-        ts.factory.createContinueStatement(),
-      ),
-    );
-  statements.push(
-    ts.factory.createExpressionStatement(
-      ts.factory.createDeleteExpression(
-        ts.factory.createElementAccessExpression(input, key),
-      ),
-    ),
-  );
-
-  return ts.factory.createForOfStatement(
-    undefined,
-    StatementFactory.constant("key").declarationList,
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier("Object.keys"),
-      undefined,
-      [input],
-    ),
-    statements.length === 1
-      ? statements[0]!
-      : ts.factory.createBlock(statements, true),
-  );
-};
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const prune_object_properties = (obj: MetadataObject) => {
+  const input: ts.Expression = ts.factory.createIdentifier("input");
+  const key: ts.Expression = ts.factory.createIdentifier("key");
+
+  const condition: ts.Expression[] = obj.properties.map((prop) => {
+    const name: string | null = prop.key.getSoleLiteral();
+    if (name !== null)
+      return ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral(name),
+        ts.factory.createIdentifier("key"),
+      );
+    return ts.factory.createCallExpression(
+      ts.factory.createIdentifier(
+        `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
+      ),
+      undefined,
+      [key],
+    );
+  });
+
+  const statements: ts.Statement[] = [];
+  if (condition.length)
+    statements.push(
+      ts.factory.createIfStatement(
+        condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+        ts.factory.createContinueStatement(),
+      ),
+    );
+  statements.push(
+    ts.factory.createExpressionStatement(
+      ts.factory.createDeleteExpression(
+        ts.factory.createElementAccessExpression(input, key),
+      ),
+    ),
+  );
+
+  return ts.factory.createForOfStatement(
+    undefined,
+    StatementFactory.constant("key").declarationList,
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier("Object.keys"),
+      undefined,
+      [input],
+    ),
+    statements.length === 1
+      ? statements[0]!
+      : ts.factory.createBlock(statements, true),
+  );
+};

package/src/programmers/internal/random_custom.ts

@@ -1,37 +1,37 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { LiteralFactory } from "../../factories/LiteralFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-
-import { Customizable } from "../../typings/Customizable";
-
-/**
- * @internal
- */
-export const random_custom =
-  (accessor: (name: string) => ts.Expression) =>
-  (type: keyof Customizable) =>
-  (tags: IMetadataTypeTag[]) =>
-  (expression: ts.Expression) =>
-    ExpressionFactory.coalesce(
-      ts.factory.createCallChain(
-        ts.factory.createPropertyAccessChain(
-          accessor("customs"),
-          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-          ts.factory.createIdentifier(type),
-        ),
-        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-        undefined,
-        [
-          LiteralFactory.generate(
-            tags.map((t) => ({
-              name: t.name,
-              kind: t.kind,
-              value: t.value,
-            })),
-          ),
-        ],
-      ),
-    )(expression);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+import { Customizable } from "../../typings/Customizable";
+
+/**
+ * @internal
+ */
+export const random_custom =
+  (accessor: (name: string) => ts.Expression) =>
+  (type: keyof Customizable) =>
+  (tags: IMetadataTypeTag[]) =>
+  (expression: ts.Expression) =>
+    ExpressionFactory.coalesce(
+      ts.factory.createCallChain(
+        ts.factory.createPropertyAccessChain(
+          accessor("customs"),
+          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+          ts.factory.createIdentifier(type),
+        ),
+        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+        undefined,
+        [
+          LiteralFactory.generate(
+            tags.map((t) => ({
+              name: t.name,
+              kind: t.kind,
+              value: t.value,
+            })),
+          ),
+        ],
+      ),
+    )(expression);

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("{}");