typia 7.0.0-dev.20240918 → 7.0.0-dev.20240920

package/src/programmers/helpers/NotationJoiner.ts

@@ -12,14 +12,14 @@ import { IExpressionEntry } from "./IExpressionEntry";
 export namespace NotationJoiner {
   export const object =
     (rename: (str: string) => string) =>
-    (
-      input: ts.Expression,
-      entries: IExpressionEntry<ts.Expression>[],
-    ): ts.ConciseBody => {
-      if (entries.length === 0) return ts.factory.createIdentifier("{}");
+    (props: {
+      input: ts.Expression;
+      entries: IExpressionEntry<ts.Expression>[];
+    }): ts.ConciseBody => {
+      if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
 
-      const regular = entries.filter((e) => e.key.isSoleLiteral());
-      const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+      const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+      const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
       const literal = ts.factory.createObjectLiteralExpression(
         regular.map((entry) => {
           const str: string = rename(entry.key.getSoleLiteral()!);
@@ -100,7 +100,7 @@ export namespace NotationJoiner {
           ts.factory.createCallExpression(
             ts.factory.createIdentifier("Object.entries"),
             undefined,
-            [input],
+            [props.input],
           ),
           ts.factory.createBlock(statements),
         ),
@@ -108,25 +108,28 @@ export namespace NotationJoiner {
       ]);
     };
 
-  export const tuple = (
-    children: ts.Expression[],
-    rest: ts.Expression | null,
-  ): ts.Expression => {
+  export const tuple = (props: {
+    elements: ts.Expression[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
     return ts.factory.createAsExpression(
       ts.factory.createArrayLiteralExpression(
-        rest === null
-          ? children
-          : [...children, ts.factory.createSpreadElement(rest)],
+        props.rest === null
+          ? props.elements
+          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
         true,
       ),
       TypeFactory.keyword("any"),
     );
   };
 
-  export const array = (input: ts.Expression, arrow: ts.Expression) =>
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.Expression;
+  }) =>
     ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(input, "map"),
+      ts.factory.createPropertyAccessExpression(props.input, "map"),
       undefined,
-      [arrow],
+      [props.arrow],
     );
 }

package/src/programmers/helpers/PruneJoiner.ts

@@ -9,14 +9,14 @@ import { prune_object_properties } from "../internal/prune_object_properties";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace PruneJoiner {
-  export const object = (
-    input: ts.Expression,
-    entries: IExpressionEntry[],
-    obj: MetadataObject,
-  ): ts.ConciseBody => {
+  export const object = (props: {
+    input: ts.Expression;
+    entries: IExpressionEntry[];
+    object: MetadataObject;
+  }): ts.ConciseBody => {
     // PREPARE ASSETS
-    const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-    const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
 
     const statements: ts.Statement[] = regular
       .map((entry) =>
@@ -28,27 +28,34 @@ export namespace PruneJoiner {
     if (dynamic.length)
       statements.push(
         ts.factory.createExpressionStatement(
-          iterate_dynamic_properties({ regular, dynamic })(input),
+          iterate_dynamic_properties({
+            regular,
+            dynamic,
+            input: props.input,
+          }),
         ),
       );
 
-    statements.push(prune_object_properties(obj));
+    statements.push(prune_object_properties(props.object));
     return ts.factory.createBlock(statements, true);
   };
 
-  export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.ArrowFunction;
+  }) =>
     ts.factory.createCallExpression(
-      IdentifierFactory.access(input)("forEach"),
+      IdentifierFactory.access(props.input)("forEach"),
       undefined,
-      [arrow],
+      [props.arrow],
     );
 
-  export const tuple = (
-    children: ts.ConciseBody[],
-    rest: ts.ConciseBody | null,
-  ): ts.Block => {
-    const entire: ts.ConciseBody[] = [...children];
-    if (rest !== null) entire.push(rest);
+  export const tuple = (props: {
+    elements: ts.ConciseBody[];
+    rest: ts.ConciseBody | null;
+  }): ts.Block => {
+    const entire: ts.ConciseBody[] = [...props.elements];
+    if (props.rest !== null) entire.push(props.rest);
 
     const statements: ts.Statement[] = entire
       .map((elem) =>
@@ -61,79 +68,77 @@ export namespace PruneJoiner {
   };
 }
 
-const iterate_dynamic_properties =
-  (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
-  (input: ts.Expression) =>
-    ts.factory.createCallExpression(
-      IdentifierFactory.access(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("Object.entries"),
-          undefined,
-          [input],
-        ),
-      )("forEach"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [
-            IdentifierFactory.parameter(
-              ts.factory.createArrayBindingPattern(
-                ["key", "value"].map((l) =>
-                  ts.factory.createBindingElement(
-                    undefined,
-                    undefined,
-                    ts.factory.createIdentifier(l),
-                    undefined,
-                  ),
+const iterate_dynamic_properties = (props: {
+  regular: IExpressionEntry[];
+  dynamic: IExpressionEntry[];
+  input: ts.Expression;
+}) =>
+  ts.factory.createCallExpression(
+    IdentifierFactory.access(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("Object.entries"),
+        undefined,
+        [props.input],
+      ),
+    )("forEach"),
+    undefined,
+    [
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            ts.factory.createArrayBindingPattern(
+              ["key", "value"].map((l) =>
+                ts.factory.createBindingElement(
+                  undefined,
+                  undefined,
+                  ts.factory.createIdentifier(l),
+                  undefined,
                 ),
               ),
             ),
-          ],
-          undefined,
-          undefined,
-          ts.factory.createBlock(
-            [
+          ),
+        ],
+        undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createIfStatement(
+              ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("undefined"),
+                ts.factory.createIdentifier("value"),
+              ),
+              ts.factory.createReturnStatement(),
+            ),
+            ...props.regular.map(({ key }) =>
               ts.factory.createIfStatement(
                 ts.factory.createStrictEquality(
-                  ts.factory.createIdentifier("undefined"),
-                  ts.factory.createIdentifier("value"),
+                  ts.factory.createStringLiteral(key.getSoleLiteral()!),
+                  ts.factory.createIdentifier("key"),
                 ),
                 ts.factory.createReturnStatement(),
               ),
-              ...props.regular.map(({ key }) =>
-                ts.factory.createIfStatement(
-                  ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral(key.getSoleLiteral()!),
-                    ts.factory.createIdentifier("key"),
-                  ),
-                  ts.factory.createReturnStatement(),
-                ),
-              ),
-              ...props.dynamic.map((dynamic) =>
-                ts.factory.createIfStatement(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                      `RegExp(/${metadata_to_pattern(true)(
-                        dynamic.key,
-                      )}/).test`,
-                    ),
-                    undefined,
-                    [ts.factory.createIdentifier("key")],
+            ),
+            ...props.dynamic.map((dynamic) =>
+              ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier(
+                    `RegExp(/${metadata_to_pattern(true)(dynamic.key)}/).test`,
                   ),
-                  ts.isBlock(dynamic.expression)
-                    ? dynamic.expression
-                    : ts.factory.createBlock([
-                        ts.factory.createExpressionStatement(
-                          dynamic.expression,
-                        ),
-                      ]),
+                  undefined,
+                  [ts.factory.createIdentifier("key")],
                 ),
+                ts.isBlock(dynamic.expression)
+                  ? dynamic.expression
+                  : ts.factory.createBlock([
+                      ts.factory.createExpressionStatement(dynamic.expression),
+                    ]),
               ),
-            ],
-            true,
-          ),
+            ),
+          ],
+          true,
         ),
-      ],
-    );
+      ),
+    ],
+  );

package/src/programmers/helpers/RandomRanger.ts

@@ -1,171 +1,171 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-
-export namespace RandomRanger {
-  export interface IDefaults {
-    minimum: number;
-    maximum: number;
-    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;
-
-      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;
-
-      return ts.factory.createCallExpression(coalesce("integer"), undefined, [
-        ExpressionFactory.number(props.minimum),
-        ExpressionFactory.number(props.maximum),
-      ]);
-    };
-  export namespace length {
-    export interface IAccessors {
-      minimum: string;
-      maximum: string;
-    }
-  }
-
-  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"),
-      };
-
-      //----
-      // 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]),
-        );
-      }
-
-      //----
-      // RANGE
-      //----
-      // INT
-      const integer = (value: number) => value === Math.floor(value);
-      if (config.type === "int") {
-        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);
-        }
-        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;
-        }
-      }
-
-      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]);
-    };
-  export namespace number {
-    export interface IConfig {
-      setter: (args: number[]) => ts.Expression;
-      transform: (value: number) => ts.Expression;
-      type: "int" | "uint" | "double";
-    }
-  }
-}
-
-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 multiplier = (gap: number) => (range: IRange) => (m: number) => {
-  const minimum: number =
-    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
-            : x;
-        })() / m;
-  const maximum: number =
-    range.maximum.value === undefined
-      ? gap
-      : (() => {
-          const y: number = m * Math.floor(range.maximum.value / m);
-          return range.maximum.exclusive && y === range.maximum.value
-            ? y - m
-            : y;
-        })() / m;
-  return { minimum, maximum };
-};
-
-interface IRange {
-  minimum: IScalar;
-  maximum: IScalar;
-}
-interface IScalar {
-  value?: undefined | number;
-  exclusive: boolean;
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+export namespace RandomRanger {
+  export interface IDefaults {
+    minimum: number;
+    maximum: number;
+    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;
+
+      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;
+
+      return ts.factory.createCallExpression(coalesce("integer"), undefined, [
+        ExpressionFactory.number(props.minimum),
+        ExpressionFactory.number(props.maximum),
+      ]);
+    };
+  export namespace length {
+    export interface IAccessors {
+      minimum: string;
+      maximum: string;
+    }
+  }
+
+  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"),
+      };
+
+      //----
+      // 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]),
+        );
+      }
+
+      //----
+      // 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);
+        }
+        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;
+        }
+      }
+
+      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]);
+    };
+  export namespace number {
+    export interface IConfig {
+      setter: (args: number[]) => ts.Expression;
+      transform: (value: number) => ts.Expression;
+      type: "int" | "uint" | "double";
+    }
+  }
+}
+
+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 multiplier = (gap: number) => (range: IRange) => (m: number) => {
+  const minimum: number =
+    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
+            : x;
+        })() / m;
+  const maximum: number =
+    range.maximum.value === undefined
+      ? gap
+      : (() => {
+          const y: number = m * Math.floor(range.maximum.value / m);
+          return range.maximum.exclusive && y === range.maximum.value
+            ? y - m
+            : y;
+        })() / m;
+  return { minimum, maximum };
+};
+
+interface IRange {
+  minimum: IScalar;
+  maximum: IScalar;
+}
+interface IScalar {
+  value?: undefined | number;
+  exclusive: boolean;
+}