typia 7.0.0-dev.20240920 → 7.0.0-dev.20240921

package/src/programmers/helpers/RandomJoiner.ts

@@ -13,130 +13,141 @@ import { Escaper } from "../../utils/Escaper";
 export namespace RandomJoiner {
   export type Decoder = (meta: Metadata) => ts.Expression;
 
-  export const array =
-    (coalesce: (method: string) => ts.Expression) =>
-    (decoder: Decoder) =>
-    (explore: IExplore) =>
-    (length: ts.Expression | undefined, unique: ts.Expression | undefined) =>
-    (item: Metadata): ts.Expression => {
-      const generator: ts.Expression = ts.factory.createCallExpression(
-        coalesce("array"),
-        undefined,
-        [
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [],
-            undefined,
-            undefined,
-            decoder(item),
-          ),
-          ...(length
-            ? [length]
-            : unique
-              ? [ts.factory.createIdentifier("undefined")]
-              : []),
-          ...(unique ? [unique] : []),
-        ],
-      );
-      if (explore.recursive === false) return generator;
-      return ts.factory.createConditionalExpression(
-        ts.factory.createGreaterThanEquals(
-          ExpressionFactory.number(5),
-          ts.factory.createIdentifier("_depth"),
+  export const array = (props: {
+    coalesce: (method: string) => ts.Expression;
+    decode: Decoder;
+    explore: IExplore;
+    length: ts.Expression | undefined;
+    unique: ts.Expression | undefined;
+    metadata: Metadata;
+  }): ts.Expression => {
+    const generator: ts.Expression = ts.factory.createCallExpression(
+      props.coalesce("array"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [],
+          undefined,
+          undefined,
+          props.decode(props.metadata),
         ),
-        undefined,
-        generator,
-        undefined,
-        ts.factory.createArrayLiteralExpression([]),
-      );
-    };
+        ...(props.length
+          ? [props.length]
+          : props.unique
+            ? [ts.factory.createIdentifier("undefined")]
+            : []),
+        ...(props.unique ? [props.unique] : []),
+      ],
+    );
+    if (props.explore.recursive === false) return generator;
+    return ts.factory.createConditionalExpression(
+      ts.factory.createGreaterThanEquals(
+        ExpressionFactory.number(5),
+        ts.factory.createIdentifier("_depth"),
+      ),
+      undefined,
+      generator,
+      undefined,
+      ts.factory.createArrayLiteralExpression([]),
+    );
+  };
 
-  export const tuple = (decoder: Decoder) => (elements: Metadata[]) =>
+  export const tuple = (props: { decode: Decoder; elements: Metadata[] }) =>
     ts.factory.createArrayLiteralExpression(
-      elements.map((elem) => decoder(elem.rest ?? elem)),
+      props.elements.map((elem) => props.decode(elem.rest ?? elem)),
       true,
     );
 
-  export const object =
-    (coalesce: (method: string) => ts.Expression) =>
-    (decoder: Decoder) =>
-    (obj: MetadataObject): ts.ConciseBody => {
-      if (obj.properties.length === 0) return ts.factory.createIdentifier("{}");
+  export const object = (props: {
+    coalesce: (method: string) => ts.Expression;
+    decode: Decoder;
+    object: MetadataObject;
+  }): ts.ConciseBody => {
+    if (props.object.properties.length === 0)
+      return ts.factory.createIdentifier("{}");
 
-      // LIST UP PROPERTIES
-      const regular = obj.properties.filter((p) => p.key.isSoleLiteral());
-      const dynamic = obj.properties.filter((p) => !p.key.isSoleLiteral());
+    // LIST UP PROPERTIES
+    const regular = props.object.properties.filter((p) =>
+      p.key.isSoleLiteral(),
+    );
+    const dynamic = props.object.properties.filter(
+      (p) => !p.key.isSoleLiteral(),
+    );
 
-      // REGULAR OBJECT
-      const literal: ts.ObjectLiteralExpression =
-        ts.factory.createObjectLiteralExpression(
-          regular.map((p) => {
-            const str: string = p.key.getSoleLiteral()!;
-            return ts.factory.createPropertyAssignment(
-              Escaper.variable(str) ? str : ts.factory.createStringLiteral(str),
-              decoder(p.value),
-            );
-          }),
-          true,
-        );
-      if (dynamic.length === 0) return literal;
+    // REGULAR OBJECT
+    const literal: ts.ObjectLiteralExpression =
+      ts.factory.createObjectLiteralExpression(
+        regular.map((p) => {
+          const str: string = p.key.getSoleLiteral()!;
+          return ts.factory.createPropertyAssignment(
+            Escaper.variable(str) ? str : ts.factory.createStringLiteral(str),
+            props.decode(p.value),
+          );
+        }),
+        true,
+      );
+    if (dynamic.length === 0) return literal;
 
-      const properties: ts.Statement[] = dynamic.map((p) =>
-        ts.factory.createExpressionStatement(
-          dynamicProperty(coalesce)(decoder)(p),
+    const properties: ts.Statement[] = dynamic.map((p) =>
+      ts.factory.createExpressionStatement(
+        dynamicProperty({
+          coalesce: props.coalesce,
+          decode: props.decode,
+          property: p,
+        }),
+      ),
+    );
+    return ts.factory.createBlock(
+      [
+        StatementFactory.constant(
+          "output",
+          ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
         ),
-      );
-      return ts.factory.createBlock(
-        [
-          StatementFactory.constant(
-            "output",
-            ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
-          ),
-          ...(obj.recursive
-            ? [
-                ts.factory.createIfStatement(
-                  ts.factory.createGreaterThanEquals(
-                    ExpressionFactory.number(5),
-                    ts.factory.createIdentifier("_depth"),
-                  ),
-                  ts.factory.createBlock(properties, true),
+        ...(props.object.recursive
+          ? [
+              ts.factory.createIfStatement(
+                ts.factory.createGreaterThanEquals(
+                  ExpressionFactory.number(5),
+                  ts.factory.createIdentifier("_depth"),
                 ),
-              ]
-            : properties),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("output"),
-          ),
-        ],
-        true,
-      );
-    };
+                ts.factory.createBlock(properties, true),
+              ),
+            ]
+          : properties),
+        ts.factory.createReturnStatement(ts.factory.createIdentifier("output")),
+      ],
+      true,
+    );
+  };
 
-  const dynamicProperty =
-    (coalesce: (method: string) => ts.Expression) =>
-    (decoder: Decoder) =>
-    (p: MetadataProperty) =>
-      ts.factory.createCallExpression(coalesce("array"), undefined, [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [],
-          undefined,
-          undefined,
-          ts.factory.createBinaryExpression(
-            ts.factory.createElementAccessExpression(
-              ts.factory.createIdentifier("output"),
-              decoder(p.key),
-            ),
-            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-            decoder(p.value),
+  const dynamicProperty = (props: {
+    coalesce: (method: string) => ts.Expression;
+    decode: Decoder;
+    property: MetadataProperty;
+  }) =>
+    ts.factory.createCallExpression(props.coalesce("array"), undefined, [
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        undefined,
+        ts.factory.createBinaryExpression(
+          ts.factory.createElementAccessExpression(
+            ts.factory.createIdentifier("output"),
+            props.decode(props.property.key),
           ),
+          ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+          props.decode(props.property.value),
         ),
-        ts.factory.createCallExpression(coalesce("integer"), undefined, [
-          ExpressionFactory.number(0),
-          ExpressionFactory.number(3),
-        ]),
-      ]);
+      ),
+      ts.factory.createCallExpression(props.coalesce("integer"), undefined, [
+        ExpressionFactory.number(0),
+        ExpressionFactory.number(3),
+      ]),
+    ]);
 }
 
 interface IExplore {

package/src/programmers/helpers/RandomRanger.ts

@@ -11,34 +11,46 @@ export namespace RandomRanger {
     gap: number;
   }
 
-  export const length =
-    (coalesce: (method: string) => ts.Expression) =>
-    (defs: IDefaults) =>
-    (acc: length.IAccessors) =>
-    (tags: IMetadataTypeTag[]): ts.Expression | undefined => {
-      const props = {
-        minimum: getter(tags)(acc.minimum),
-        maximum: getter(tags)(acc.maximum),
-      };
-      if (props.minimum === undefined && props.maximum === undefined)
-        return undefined;
+  export const length = (props: {
+    coalesce: (method: string) => ts.Expression;
+    defaults: IDefaults;
+    accessors: length.IAccessors;
+    tags: IMetadataTypeTag[];
+  }): ts.Expression | undefined => {
+    const range = {
+      minimum: take({
+        kind: props.accessors.minimum,
+        tags: props.tags,
+      }),
+      maximum: take({
+        kind: props.accessors.maximum,
+        tags: props.tags,
+      }),
+    };
+    if (range.minimum === undefined && range.maximum === undefined)
+      return undefined;
 
-      if (props.maximum !== undefined && props.minimum === undefined) {
-        if (props.maximum <= 0) {
-          props.maximum = 0;
-          props.minimum = 0;
-        } else if (props.maximum < defs.gap)
-          props.minimum = defs.minimum === 0 ? 0 : 1;
-      }
-      props.minimum ??= defs.minimum;
-      props.maximum ??= defs.maximum;
-      if (props.maximum < props.minimum) (props.maximum as number) += defs.gap;
+    if (range.maximum !== undefined && range.minimum === undefined) {
+      if (range.maximum <= 0) {
+        range.maximum = 0;
+        range.minimum = 0;
+      } else if (range.maximum < props.defaults.gap)
+        range.minimum = props.defaults.minimum === 0 ? 0 : 1;
+    }
+    range.minimum ??= props.defaults.minimum;
+    range.maximum ??= props.defaults.maximum;
+    if (range.maximum < range.minimum)
+      (range.maximum as number) += props.defaults.gap;
 
-      return ts.factory.createCallExpression(coalesce("integer"), undefined, [
-        ExpressionFactory.number(props.minimum),
-        ExpressionFactory.number(props.maximum),
-      ]);
-    };
+    return ts.factory.createCallExpression(
+      props.coalesce("integer"),
+      undefined,
+      [
+        ExpressionFactory.number(range.minimum),
+        ExpressionFactory.number(range.maximum),
+      ],
+    );
+  };
   export namespace length {
     export interface IAccessors {
       minimum: string;
@@ -46,79 +58,109 @@ export namespace RandomRanger {
     }
   }
 
-  export const number =
-    (config: number.IConfig) =>
-    (defs: IDefaults) =>
-    (tags: IMetadataTypeTag[]): ts.Expression => {
-      const range = {
-        minimum: {
-          value: getter(tags)("minimum") ?? getter(tags)("exclusiveMinimum"),
-          exclusive: getter(tags)("exclusiveMinimum") !== undefined,
-        },
-        maximum: {
-          value: getter(tags)("maximum") ?? getter(tags)("exclusiveMaximum"),
-          exclusive: getter(tags)("exclusiveMaximum") !== undefined,
-        },
-        stepper: undefined,
-        multiply: getter(tags)("multipleOf"),
-      };
+  export const number = (props: {
+    config: number.IConfig;
+    defaults: IDefaults;
+    tags: IMetadataTypeTag[];
+  }): ts.Expression => {
+    const range = {
+      minimum: {
+        value:
+          take({
+            kind: "minimum",
+            tags: props.tags,
+          }) ??
+          take({
+            kind: "exclusiveMinimum",
+            tags: props.tags,
+          }),
+        exclusive:
+          take({
+            kind: "exclusiveMinimum",
+            tags: props.tags,
+          }) !== undefined,
+      },
+      maximum: {
+        value:
+          take({
+            kind: "maximum",
+            tags: props.tags,
+          }) ??
+          take({
+            tags: props.tags,
+            kind: "exclusiveMaximum",
+          }),
+        exclusive:
+          take({
+            kind: "exclusiveMaximum",
+            tags: props.tags,
+          }) !== undefined,
+      },
+      stepper: undefined,
+      multiply: take({
+        kind: "multipleOf",
+        tags: props.tags,
+      }),
+    };
 
-      //----
-      // MULTIPLIERS
-      //----
-      if (range.multiply !== undefined) {
-        const { minimum, maximum } = multiplier(defs.gap)(range)(
-          range.multiply,
-        );
-        return ts.factory.createMultiply(
-          config.transform(range.multiply),
-          config.setter([minimum, maximum]),
-        );
-      }
+    //----
+    // MULTIPLIERS
+    //----
+    if (range.multiply !== undefined) {
+      const { minimum, maximum } = multiplier({
+        gap: props.defaults.gap,
+        range,
+        value: range.multiply,
+      });
+      return ts.factory.createMultiply(
+        props.config.transform(range.multiply),
+        props.config.setter([minimum, maximum]),
+      );
+    }
 
-      //----
-      // RANGE
-      //----
-      // INT
-      const integer = (value: number) => value === Math.floor(value);
-      if (config.type === "int" || config.type === "uint") {
-        if (range.minimum.value !== undefined) {
-          if (range.minimum.exclusive) {
-            range.minimum.exclusive = false;
-            if (integer(range.minimum.value)) range.minimum.value += 1;
-          }
-          range.minimum.value = Math.ceil(range.minimum.value);
+    //----
+    // RANGE
+    //----
+    // INT
+    const integer = (value: number) => value === Math.floor(value);
+    if (props.config.type === "int" || props.config.type === "uint") {
+      if (range.minimum.value !== undefined) {
+        if (range.minimum.exclusive) {
+          range.minimum.exclusive = false;
+          if (integer(range.minimum.value)) range.minimum.value += 1;
         }
-        if (range.maximum.value !== undefined) {
-          if (range.maximum.exclusive) {
-            range.maximum.exclusive = false;
-            if (integer(range.maximum.value)) range.maximum.value -= 1;
-          }
-          range.maximum.value = Math.floor(range.maximum.value);
+        range.minimum.value = Math.ceil(range.minimum.value);
+      }
+      if (range.maximum.value !== undefined) {
+        if (range.maximum.exclusive) {
+          range.maximum.exclusive = false;
+          if (integer(range.maximum.value)) range.maximum.value -= 1;
         }
+        range.maximum.value = Math.floor(range.maximum.value);
       }
+    }
 
-      // UNSIGNED INT
-      if (config.type === "uint") {
-        if (range.minimum.value === undefined) range.minimum.value = 0;
-        else if (range.minimum.value <= 0) {
-          range.minimum.value = 0;
-          range.minimum.exclusive = false;
-        }
+    // UNSIGNED INT
+    if (props.config.type === "uint") {
+      if (range.minimum.value === undefined) range.minimum.value = 0;
+      else if (range.minimum.value <= 0) {
+        range.minimum.value = 0;
+        range.minimum.exclusive = false;
       }
+    }
 
-      const minimum =
-        range.minimum.value ??
-        (range.maximum.value !== undefined
-          ? range.maximum.value - defs.gap
-          : defs.minimum);
-      const maximum =
-        range.maximum.value ??
-        (range.minimum.value !== undefined
-          ? range.minimum.value + defs.gap
-          : defs.maximum);
-      return config.setter([minimum, maximum]);
-    };
+    const minimum =
+      range.minimum.value ??
+      (range.maximum.value !== undefined
+        ? range.maximum.value - props.defaults.gap
+        : props.defaults.minimum);
+    const maximum =
+      range.maximum.value ??
+      (range.minimum.value !== undefined
+        ? range.minimum.value + props.defaults.gap
+        : props.defaults.maximum);
+    return props.config.setter([minimum, maximum]);
+  };
   export namespace number {
     export interface IConfig {
       setter: (args: number[]) => ts.Expression;
@@ -128,36 +170,41 @@ export namespace RandomRanger {
   }
 }
 
-const getter =
-  (tags: IMetadataTypeTag[]) =>
-  (kind: string): number | undefined => {
-    const value: bigint | number | undefined = tags.find(
-      (t) =>
-        t.kind === kind &&
-        (typeof t.value === "number" || typeof t.value === "bigint"),
-    )?.value;
-    return value !== undefined ? Number(value) : undefined;
-  };
+const take = (props: {
+  kind: string;
+  tags: IMetadataTypeTag[];
+}): number | undefined => {
+  const value: bigint | number | undefined = props.tags.find(
+    (t) =>
+      t.kind === props.kind &&
+      (typeof t.value === "number" || typeof t.value === "bigint"),
+  )?.value;
+  return value !== undefined ? Number(value) : undefined;
+};
 
-const multiplier = (gap: number) => (range: IRange) => (m: number) => {
+const multiplier = (props: { range: IRange; gap: number; value: number }) => {
   const minimum: number =
-    range.minimum.value === undefined
+    props.range.minimum.value === undefined
       ? 0
       : (() => {
-          const x: number = m * Math.ceil(range.minimum.value / m);
-          return range.minimum.exclusive && x === range.minimum.value
-            ? x + m
+          const x: number =
+            props.value * Math.ceil(props.range.minimum.value / props.value);
+          return props.range.minimum.exclusive &&
+            x === props.range.minimum.value
+            ? x + props.value
             : x;
-        })() / m;
+        })() / props.value;
   const maximum: number =
-    range.maximum.value === undefined
-      ? gap
+    props.range.maximum.value === undefined
+      ? props.gap
       : (() => {
-          const y: number = m * Math.floor(range.maximum.value / m);
-          return range.maximum.exclusive && y === range.maximum.value
-            ? y - m
+          const y: number =
+            props.value * Math.floor(props.range.maximum.value / props.value);
+          return props.range.maximum.exclusive &&
+            y === props.range.maximum.value
+            ? y - props.value
             : y;
-        })() / m;
+        })() / props.value;
   return { minimum, maximum };
 };
 

package/src/programmers/helpers/StringifyJoinder.ts

@@ -9,52 +9,54 @@ import { FunctionImporter } from "./FunctionImporter";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace StringifyJoiner {
-  export const object =
-    (importer: FunctionImporter) =>
-    (props: { entries: IExpressionEntry<ts.Expression>[] }): ts.Expression => {
-      // CHECK AND SORT ENTRIES
-      if (props.entries.length === 0)
-        return ts.factory.createStringLiteral("{}");
+  export const object = (props: {
+    importer: FunctionImporter;
+    entries: IExpressionEntry<ts.Expression>[];
+  }): ts.Expression => {
+    // CHECK AND SORT ENTRIES
+    if (props.entries.length === 0) return ts.factory.createStringLiteral("{}");
 
-      // PROPERTIES
-      const regular: IExpressionEntry<ts.Expression>[] = props.entries.filter(
-        (entry) => entry.key.isSoleLiteral(),
-      );
-      const dynamic: IExpressionEntry<ts.Expression>[] = props.entries.filter(
-        (entry) => !entry.key.isSoleLiteral(),
-      );
-      const expressions: ts.Expression[] = [
-        ...stringify_regular_properties(regular, dynamic),
-        ...(dynamic.length
-          ? [
-              stringify_dynamic_properties(
-                dynamic,
-                regular.map((r) => r.key.getSoleLiteral()!),
-              ),
-            ]
-          : []),
-      ];
+    // PROPERTIES
+    const regular: IExpressionEntry<ts.Expression>[] = props.entries.filter(
+      (entry) => entry.key.isSoleLiteral(),
+    );
+    const dynamic: IExpressionEntry<ts.Expression>[] = props.entries.filter(
+      (entry) => !entry.key.isSoleLiteral(),
+    );
+    const expressions: ts.Expression[] = [
+      ...stringify_regular_properties(regular, dynamic),
+      ...(dynamic.length
+        ? [
+            stringify_dynamic_properties(
+              dynamic,
+              regular.map((r) => r.key.getSoleLiteral()!),
+            ),
+          ]
+        : []),
+    ];
 
-      // POP LAST COMMA, IF REQUIRED
-      const filtered: ts.Expression[] =
-        (regular.length &&
-          regular[regular.length - 1]!.meta.isRequired() &&
-          dynamic.length === 0) ||
-        (regular.length === 0 && dynamic.length)
-          ? expressions
-          : [
-              ts.factory.createCallExpression(importer.use("tail"), undefined, [
-                TemplateFactory.generate(expressions),
-              ]),
-            ];
+    // POP LAST COMMA, IF REQUIRED
+    const filtered: ts.Expression[] =
+      (regular.length &&
+        regular[regular.length - 1]!.meta.isRequired() &&
+        dynamic.length === 0) ||
+      (regular.length === 0 && dynamic.length)
+        ? expressions
+        : [
+            ts.factory.createCallExpression(
+              props.importer.use("tail"),
+              undefined,
+              [TemplateFactory.generate(expressions)],
+            ),
+          ];
 
-      // RETURNS WITH OBJECT BRACKET
-      return TemplateFactory.generate([
-        ts.factory.createStringLiteral(`{`),
-        ...filtered,
-        ts.factory.createStringLiteral(`}`),
-      ]);
-    };
+    // RETURNS WITH OBJECT BRACKET
+    return TemplateFactory.generate([
+      ts.factory.createStringLiteral(`{`),
+      ...filtered,
+      ts.factory.createStringLiteral(`}`),
+    ]);
+  };
 
   export const array = (props: {
     input: ts.Expression;