typia 3.5.0-dev.20230213 → 3.5.0-dev.20230214

package/src/programmers/helpers/RandomJoiner.ts

@@ -0,0 +1,140 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+import { MetadataProperty } from "../../metadata/MetadataProperty";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { RandomRanger } from "./RandomRanger";
+
+export namespace RandomJoiner {
+    export type Decoder = (
+        meta: Metadata,
+        tags: IMetadataTag[],
+    ) => ts.Expression;
+
+    export const array =
+        (decoder: Decoder) => (item: Metadata, tags: IMetadataTag[]) => {
+            const tail = RandomRanger.length({
+                minimum: 0,
+                maximum: 3,
+                gap: 3,
+            })({
+                fixed: "items",
+                minimum: "minItems",
+                maximum: "maxItems",
+            })(tags);
+            return ts.factory.createCallExpression(
+                ts.factory.createIdentifier("generator.array"),
+                undefined,
+                [
+                    ts.factory.createArrowFunction(
+                        undefined,
+                        undefined,
+                        [],
+                        undefined,
+                        undefined,
+                        decoder(item, tags),
+                    ),
+                    ...(tail ? [tail] : []),
+                ],
+            );
+        };
+
+    export const tuple =
+        (decoder: Decoder) => (items: Metadata[], tags: IMetadataTag[]) =>
+            ts.factory.createArrayLiteralExpression(
+                items.map((i) => decoder(i.rest ?? i, tags)),
+                true,
+            );
+
+    export const object =
+        (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, p.tags),
+                        );
+                    }),
+                    true,
+                );
+            if (dynamic.length === 0) return literal;
+
+            const properties: ts.Statement[] = dynamic.map((p) =>
+                ts.factory.createExpressionStatement(
+                    dynamicProperty(decoder)(p),
+                ),
+            );
+            return ts.factory.createBlock(
+                [
+                    StatementFactory.constant("output", literal),
+                    ...(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 = (decoder: Decoder) => (p: MetadataProperty) =>
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("generator.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, p.tags),
+                    ),
+                ),
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("generator.integer"),
+                    undefined,
+                    [
+                        ts.factory.createNumericLiteral(0),
+                        ts.factory.createNumericLiteral(3),
+                    ],
+                ),
+            ],
+        );
+}

package/src/programmers/helpers/RandomRanger.ts

@@ -0,0 +1,215 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+export namespace RandomRanger {
+    export interface IDefaults {
+        minimum: number;
+        maximum: number;
+        gap: number;
+    }
+
+    export const length =
+        (defs: IDefaults) =>
+        (acc: length.IAccessors) =>
+        (tags: IMetadataTag[]) => {
+            const props = {
+                fixed: getter(tags)(acc.fixed),
+                minimum: getter(tags)(acc.minimum),
+                maximum: getter(tags)(acc.maximum),
+            };
+            if (props.fixed !== undefined)
+                return ts.factory.createNumericLiteral(props.fixed);
+            else 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(
+                ts.factory.createIdentifier("generator.integer"),
+                undefined,
+                [
+                    ts.factory.createNumericLiteral(props.minimum),
+                    ts.factory.createNumericLiteral(props.maximum),
+                ],
+            );
+        };
+    export namespace length {
+        export interface IAccessors {
+            minimum: IMetadataTag["kind"];
+            maximum: IMetadataTag["kind"];
+            fixed: IMetadataTag["kind"];
+        }
+    }
+
+    export const number =
+        (config: number.IConfig) =>
+        (defs: IDefaults) =>
+        (tags: IMetadataTag[]): 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,
+                },
+                step: getter(tags)("step"),
+                multiply: getter(tags)("multipleOf"),
+            };
+            if (Object.values(range).every((v) => v !== undefined))
+                return config.setter([]);
+
+            //----
+            // MULTIPLIERS
+            //----
+            // STEP
+            if (range.step !== undefined) {
+                const { intercept, minimum, maximum } = stepper(defs.gap)(
+                    range,
+                )(range.step);
+                return ts.factory.createAdd(
+                    config.transform(intercept),
+                    ts.factory.createMultiply(
+                        config.transform(range.step),
+                        config.setter([minimum, maximum]),
+                    ),
+                );
+            }
+            // MULTIPLE-OF
+            else 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 (
+                tags.find(
+                    (t) => t.kind === "type" && t.value.indexOf("int") !== -1,
+                ) !== undefined
+            ) {
+                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 (
+                tags.find(
+                    (t) => t.kind === "type" && t.value.indexOf("uint") === 0,
+                ) !== undefined
+            ) {
+                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: IMetadataTag[]) =>
+    (kind: IMetadataTag["kind"]): number | undefined =>
+        tags.find((t) => t.kind === kind)?.value as number | undefined;
+
+const stepper = (gap: number) => (range: IRange) => (s: number) => {
+    const intercept: number = range.minimum.value!;
+    const minimum: number = range.minimum.exclusive ? 1 : 0;
+    if (range.maximum.value === undefined)
+        return {
+            intercept,
+            minimum,
+            maximum: gap,
+        };
+
+    const y: number = Math.floor(range.maximum.value - intercept) / s;
+    return {
+        intercept,
+        minimum,
+        maximum:
+            range.maximum.exclusive && intercept + y * s === range.maximum.value
+                ? y - 1
+                : y,
+    };
+};
+
+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;
+}

package/src/programmers/helpers/StringifyJoinder.ts

@@ -16,16 +16,16 @@ export namespace StringifyJoiner {
             entries: IExpressionEntry<ts.Expression>[],
         ): ts.Expression => {
             // CHECK AND SORT ENTRIES
+            if (entries.length === 0)
+                return ts.factory.createStringLiteral("{}");
+
+            // PROPERTIES
             const regular: IExpressionEntry<ts.Expression>[] = entries.filter(
                 (entry) => entry.key.isSoleLiteral(),
             );
             const dynamic: IExpressionEntry<ts.Expression>[] = entries.filter(
                 (entry) => !entry.key.isSoleLiteral(),
             );
-            if (regular.length === 0 && dynamic.length === 0)
-                return ts.factory.createStringLiteral("{}");
-
-            // PROPERTIES
             const expressions: ts.Expression[] = [
                 ...stringify_regular_properties(regular, dynamic),
                 ...(dynamic.length

package/src/programmers/internal/application_array.ts

@@ -33,15 +33,5 @@ export const application_array =
         for (const tag of attribute["x-typia-metaTags"] || [])
             if (tag.kind === "minItems") output.minItems = tag.value;
             else if (tag.kind === "maxItems") output.maxItems = tag.value;
-            else if (tag.kind === "items") {
-                if (tag.minimum !== undefined)
-                    output.minItems =
-                        tag.minimum.value +
-                        (tag.minimum.include === true ? 0 : 1);
-                if (tag.maximum !== undefined)
-                    output.maxItems =
-                        tag.maximum.value -
-                        (tag.maximum.include === true ? 0 : 1);
-            }
         return output;
     };

package/src/programmers/internal/application_number.ts

@@ -7,9 +7,9 @@ import { application_default } from "./application_default";
 export const application_number = (
     nullable: boolean,
     attribute: IJsonSchema.IAttribute,
-): IJsonSchema.INumber => {
-    const output: IJsonSchema.INumber = {
-        type: "number",
+): IJsonSchema.INumber | IJsonSchema.IInteger => {
+    const output: IJsonSchema.INumber | IJsonSchema.IInteger = {
+        type: "number" as "number" | "integer",
         nullable,
         ...attribute,
     };
@@ -23,16 +23,10 @@ export const application_number = (
         // RANGE TAG
         else if (tag.kind === "minimum") output.minimum = tag.value;
         else if (tag.kind === "maximum") output.maximum = tag.value;
-        else if (tag.kind === "range") {
-            if (tag.minimum !== undefined)
-                if (tag.minimum.include === true)
-                    output.minimum = tag.minimum.value;
-                else output.exclusiveMinimum = tag.minimum.value;
-            if (tag.maximum !== undefined)
-                if (tag.maximum.include === true)
-                    output.maximum = tag.maximum.value;
-                else output.exclusiveMaximum = tag.maximum.value;
-        }
+        else if (tag.kind === "exclusiveMinimum")
+            output.exclusiveMinimum = tag.value;
+        else if (tag.kind === "exclusiveMaximum")
+            output.exclusiveMaximum = tag.value;
         // MULTIPLE-OF
         else if (tag.kind === "multipleOf") output.multipleOf = tag.value;
     }

package/src/programmers/internal/application_string.ts

@@ -28,14 +28,6 @@ export const application_string = (
         // RANGE
         if (tag.kind === "minLength") output.minLength = tag.value;
         else if (tag.kind === "maxLength") output.maxLength = tag.value;
-        else if (tag.kind === "length") {
-            if (tag.minimum !== undefined)
-                output.minLength =
-                    tag.minimum.value + (tag.minimum.include ? 0 : 1);
-            if (tag.maximum !== undefined)
-                output.maxLength =
-                    tag.maximum.value - (tag.maximum.include ? 0 : 1);
-        }
         // FORMAT AND PATTERN
         else if (tag.kind === "format") output.format = tag.value;
         else if (tag.kind === "pattern") output.pattern = tag.value;

package/src/programmers/internal/check_array_length.ts

@@ -4,8 +4,6 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
-import { check_length } from "./check_length";
-
 /**
  * @internal
  */
@@ -17,7 +15,14 @@ export function check_array_length(
 
     // CHECK TAGS
     for (const tag of tagList)
-        if (tag.kind === "minItems")
+        if (tag.kind === "items")
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createNumericLiteral(tag.value),
+                    IdentifierFactory.join(input, "length"),
+                ),
+            );
+        else if (tag.kind === "minItems")
             conditions.push(
                 ts.factory.createLessThanEquals(
                     ts.factory.createNumericLiteral(tag.value),
@@ -31,12 +36,6 @@ export function check_array_length(
                     IdentifierFactory.join(input, "length"),
                 ),
             );
-        else if (tag.kind === "items")
-            check_length(
-                conditions,
-                IdentifierFactory.join(input, "length"),
-                tag,
-            );
 
     // COMBINATION
     return conditions.length

package/src/programmers/internal/check_bigint.ts

@@ -30,8 +30,6 @@ export function check_bigint(input: ts.Expression, tagList: IMetadataTag[]) {
                 for (const tag of tagList)
                     if (tag.kind === "minimum") return tag.value;
                     else if (tag.kind === "exclusiveMinimum") return tag.value;
-                    else if (tag.kind === "range" && tag.minimum !== undefined)
-                        return tag.minimum.value;
                 return undefined;
             })();
             conditions.push(
@@ -42,25 +40,6 @@ export function check_bigint(input: ts.Expression, tagList: IMetadataTag[]) {
                         : modulo(),
                 ),
             );
-        } else if (tag.kind === "range") {
-            if (tag.minimum !== undefined)
-                conditions.push(
-                    (tag.minimum.include
-                        ? ts.factory.createLessThanEquals
-                        : ts.factory.createLessThan)(
-                        caster(tag.minimum.value),
-                        input,
-                    ),
-                );
-            if (tag.maximum !== undefined)
-                conditions.push(
-                    (tag.maximum.include
-                        ? ts.factory.createLessThanEquals
-                        : ts.factory.createLessThan)(
-                        input,
-                        caster(tag.maximum.value),
-                    ),
-                );
         } else if (tag.kind === "minimum")
             conditions.push(
                 ts.factory.createLessThanEquals(caster(tag.value), input),

package/src/programmers/internal/check_number.ts

@@ -22,12 +22,6 @@ export const check_number =
 
         // CHECK FINITE AND NAN
         const finite: boolean =
-            !!tagList.find(
-                (tag) =>
-                    tag.kind === "range" &&
-                    tag.minimum !== undefined &&
-                    tag.maximum !== undefined,
-            ) ||
             (!!tagList.find(
                 (tag) =>
                     tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
@@ -102,11 +96,6 @@ export const check_number =
                         if (tag.kind === "minimum") return tag.value;
                         else if (tag.kind === "exclusiveMinimum")
                             return tag.value;
-                        else if (
-                            tag.kind === "range" &&
-                            tag.minimum !== undefined
-                        )
-                            return tag.minimum.value;
                     return undefined;
                 })();
                 conditions.push(
@@ -120,25 +109,6 @@ export const check_number =
                             : modulo(),
                     ),
                 );
-            } else if (tag.kind === "range") {
-                if (tag.minimum !== undefined)
-                    conditions.push(
-                        (tag.minimum.include
-                            ? ts.factory.createLessThanEquals
-                            : ts.factory.createLessThan)(
-                            ts.factory.createNumericLiteral(tag.minimum.value),
-                            input,
-                        ),
-                    );
-                if (tag.maximum !== undefined)
-                    conditions.push(
-                        (tag.maximum.include
-                            ? ts.factory.createLessThanEquals
-                            : ts.factory.createLessThan)(
-                            input,
-                            ts.factory.createNumericLiteral(tag.maximum.value),
-                        ),
-                    );
             } else if (tag.kind === "minimum")
                 conditions.push(
                     ts.factory.createLessThanEquals(

package/src/programmers/internal/check_string_tags.ts

@@ -5,7 +5,6 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { check_length } from "./check_length";
 
 /**
  * @internal
@@ -39,6 +38,13 @@ export const check_string_tags =
                         ),
                     ),
                 );
+            else if (tag.kind === "length")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input, "length"),
+                    ),
+                );
             else if (tag.kind === "minLength")
                 conditions.push(
                     ts.factory.createLessThanEquals(
@@ -53,11 +59,5 @@ export const check_string_tags =
                         IdentifierFactory.join(input, "length"),
                     ),
                 );
-            else if (tag.kind === "length")
-                check_length(
-                    conditions,
-                    IdentifierFactory.join(input, "length"),
-                    tag,
-                );
         return conditions;
     };

package/src/schemas/IJsonSchema.ts

@@ -10,6 +10,7 @@ export namespace IJsonSchema {
         | IEnumeration<"number">
         | IEnumeration<"string">
         | IBoolean
+        | IInteger
         | INumber
         | IString
         | IArray
@@ -32,18 +33,46 @@ export namespace IJsonSchema {
         default?: Atomic.Mapper[Literal];
     }
     export interface IString extends IAtomic<"string"> {
+        /**
+         * @type uint
+         */
         minLength?: number;
+        /**
+         * @type uint
+         */
         maxLength?: number;
         pattern?: string;
         format?: string;
     }
-    export interface INumber extends IAtomic<"number" | "integer"> {
+    export interface INumber extends IAtomic<"number"> {
         minimum?: number;
         maximum?: number;
         exclusiveMinimum?: number;
         exclusiveMaximum?: number;
         multipleOf?: number;
     }
+    export interface IInteger extends IAtomic<"integer"> {
+        /**
+         * @type int
+         */
+        minimum?: number;
+        /**
+         * @type int
+         */
+        maximum?: number;
+        /**
+         * @type int
+         */
+        exclusiveMinimum?: number;
+        /**
+         * @type int
+         */
+        exclusiveMaximum?: number;
+        /**
+         * @type int
+         */
+        multipleOf?: number;
+    }
     export interface IBoolean extends IAtomic<"boolean"> {}
 
     /* -----------------------------------------------------------
@@ -51,7 +80,13 @@ export namespace IJsonSchema {
     ----------------------------------------------------------- */
     export interface IArray extends ISignificant<"array"> {
         items: IJsonSchema;
+        /**
+         * @type uint
+         */
         minItems?: number;
+        /**
+         * @type uint
+         */
         maxItems?: number;
         "x-typia-tuple"?: ITuple;
     }