typia 6.10.2-dev.20240920 → 6.10.2

package/src/programmers/helpers/RandomJoiner.ts

@@ -1,145 +1,145 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-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"),
-        ),
-        undefined,
-        generator,
-        undefined,
-        ts.factory.createArrayLiteralExpression([]),
-      );
-    };
-
-  export const tuple = (decoder: Decoder) => (elements: Metadata[]) =>
-    ts.factory.createArrayLiteralExpression(
-      elements.map((elem) => decoder(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("{}");
-
-      // LIST UP PROPERTIES
-      const regular = obj.properties.filter((p) => p.key.isSoleLiteral());
-      const dynamic = obj.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;
-
-      const properties: ts.Statement[] = dynamic.map((p) =>
-        ts.factory.createExpressionStatement(
-          dynamicProperty(coalesce)(decoder)(p),
-        ),
-      );
-      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),
-                ),
-              ]
-            : 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),
-          ),
-        ),
-        ts.factory.createCallExpression(coalesce("integer"), undefined, [
-          ExpressionFactory.number(0),
-          ExpressionFactory.number(3),
-        ]),
-      ]);
-}
-
-interface IExplore {
-  function: boolean;
-  recursive: boolean;
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+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"),
+        ),
+        undefined,
+        generator,
+        undefined,
+        ts.factory.createArrayLiteralExpression([]),
+      );
+    };
+
+  export const tuple = (decoder: Decoder) => (elements: Metadata[]) =>
+    ts.factory.createArrayLiteralExpression(
+      elements.map((elem) => decoder(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("{}");
+
+      // LIST UP PROPERTIES
+      const regular = obj.properties.filter((p) => p.key.isSoleLiteral());
+      const dynamic = obj.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;
+
+      const properties: ts.Statement[] = dynamic.map((p) =>
+        ts.factory.createExpressionStatement(
+          dynamicProperty(coalesce)(decoder)(p),
+        ),
+      );
+      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),
+                ),
+              ]
+            : 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),
+          ),
+        ),
+        ts.factory.createCallExpression(coalesce("integer"), undefined, [
+          ExpressionFactory.number(0),
+          ExpressionFactory.number(3),
+        ]),
+      ]);
+}
+
+interface IExplore {
+  function: boolean;
+  recursive: boolean;
+}

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" || 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;
-}
+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;
+}