typia 5.0.4 → 5.0.5-dev.20230921

package/src/programmers/helpers/RandomJoiner.ts

@@ -1,151 +1,151 @@
-import ts from "typescript";
-
-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) =>
-        (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] : []),
-                ],
-            );
-            if (explore.recursive === false) return generator;
-            return ts.factory.createConditionalExpression(
-                ts.factory.createGreaterThanEquals(
-                    ts.factory.createNumericLiteral(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(
-                                      ts.factory.createNumericLiteral(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,
-                    [
-                        ts.factory.createNumericLiteral(0),
-                        ts.factory.createNumericLiteral(3),
-                    ],
-                ),
-            ]);
-}
-
-interface IExplore {
-    function: boolean;
-    recursive: boolean;
-}
+import ts from "typescript";
+
+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) =>
+        (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] : []),
+                ],
+            );
+            if (explore.recursive === false) return generator;
+            return ts.factory.createConditionalExpression(
+                ts.factory.createGreaterThanEquals(
+                    ts.factory.createNumericLiteral(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(
+                                      ts.factory.createNumericLiteral(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,
+                    [
+                        ts.factory.createNumericLiteral(0),
+                        ts.factory.createNumericLiteral(3),
+                    ],
+                ),
+            ]);
+}
+
+interface IExplore {
+    function: boolean;
+    recursive: boolean;
+}

package/src/programmers/helpers/RandomRanger.ts

@@ -1,173 +1,173 @@
-import ts from "typescript";
-
-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;
-
-            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,
-                [
-                    ts.factory.createNumericLiteral(props.minimum),
-                    ts.factory.createNumericLiteral(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?: number;
-    exclusive: boolean;
-}
+import ts from "typescript";
+
+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;
+
+            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,
+                [
+                    ts.factory.createNumericLiteral(props.minimum),
+                    ts.factory.createNumericLiteral(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?: number;
+    exclusive: boolean;
+}