typia 3.8.0-dev.20230417 → 3.8.0-dev.20230420

package/src/programmers/helpers/RandomRanger.ts

@@ -1,216 +1,216 @@
-import ts from "typescript";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-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: IMetadataTag[]): ts.Expression | undefined => {
-            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(
-                coalesce("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;
-}
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+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: IMetadataTag[]): ts.Expression | undefined => {
+            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(
+                coalesce("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

@@ -61,16 +61,16 @@ export namespace StringifyJoiner {
             ]);
         };
 
-    export function array(
+    export const array = (
         input: ts.Expression,
         arrow: ts.ArrowFunction,
-    ): ts.Expression {
-        return TemplateFactory.generate([
+    ): ts.Expression =>
+        TemplateFactory.generate([
             ts.factory.createStringLiteral(`[`),
             ts.factory.createCallExpression(
                 ts.factory.createPropertyAccessExpression(
                     ts.factory.createCallExpression(
-                        IdentifierFactory.join(input, "map"),
+                        IdentifierFactory.join(input)("map"),
                         undefined,
                         [arrow],
                     ),
@@ -81,12 +81,11 @@ export namespace StringifyJoiner {
             ),
             ts.factory.createStringLiteral(`]`),
         ]);
-    }
 
-    export function tuple(
+    export const tuple = (
         children: ts.Expression[],
         rest: ts.Expression | null,
-    ): ts.Expression {
+    ): ts.Expression => {
         if (children.length === 0) return ts.factory.createStringLiteral("[]");
         if (
             rest === null &&
@@ -110,5 +109,5 @@ export namespace StringifyJoiner {
 
         elements.push(ts.factory.createStringLiteral(`]`));
         return TemplateFactory.generate(elements);
-    }
+    };
 }

package/src/programmers/helpers/StringifyPredicator.ts

@@ -1,18 +1,12 @@
 import { Metadata } from "../../metadata/Metadata";
 
 export namespace StringifyPredicator {
-    export function require_escape(value: string): boolean {
-        return value
-            .split("")
-            .some((ch) => ESCAPED.some((escaped) => escaped === ch));
-    }
+    export const require_escape = (value: string): boolean =>
+        value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
 
-    export function undefindable(meta: Metadata): boolean {
-        return (
-            meta.required === false ||
-            (meta.resolved !== null && meta.resolved.required === false)
-        );
-    }
+    export const undefindable = (meta: Metadata): boolean =>
+        meta.required === false ||
+        (meta.resolved !== null && meta.resolved.required === false);
 
     const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
 }

package/src/programmers/helpers/UnionExplorer.ts

@@ -75,10 +75,8 @@ export namespace UnionExplorer {
                 .filter((spec) => spec.property.key.getSoleLiteral() !== null)
                 .map((spec) => {
                     const key: string = spec.property.key.getSoleLiteral()!;
-                    const accessor: ts.Expression = IdentifierFactory.join(
-                        input,
-                        key,
-                    );
+                    const accessor: ts.Expression =
+                        IdentifierFactory.join(input)(key);
                     const pred: ts.Expression = spec.neighbour
                         ? config.objector.checker(
                               accessor,
@@ -161,7 +159,7 @@ export namespace UnionExplorer {
 
     export const array = (props: array.IProps) =>
         check_union_array_like<Metadata>({
-            size: (input) => IdentifierFactory.join(input, "length"),
+            size: (input) => IdentifierFactory.join(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
@@ -173,7 +171,7 @@ export namespace UnionExplorer {
 
     export const array_or_tuple = (props: array_or_tuple.IProps) =>
         check_union_array_like<Metadata | Metadata[]>({
-            size: (input) => IdentifierFactory.join(input, "length"),
+            size: (input) => IdentifierFactory.join(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
@@ -190,23 +188,21 @@ export namespace UnionExplorer {
 
     export const set = (props: set.IProps) =>
         check_union_array_like<Metadata>({
-            size: (input) => IdentifierFactory.join(input, "size"),
+            size: (input) => IdentifierFactory.join(input)("size"),
             front: (input) =>
                 IdentifierFactory.join(
                     ts.factory.createCallExpression(
                         IdentifierFactory.join(
                             ts.factory.createCallExpression(
-                                IdentifierFactory.join(input, "values"),
+                                IdentifierFactory.join(input)("values"),
                                 undefined,
                                 undefined,
                             ),
-                            "next",
-                        ),
+                        )("next"),
                         undefined,
                         undefined,
                     ),
-                    "value",
-                ),
+                )("value"),
             array: (input) =>
                 ts.factory.createArrayLiteralExpression(
                     [ts.factory.createSpreadElement(input)],
@@ -220,23 +216,21 @@ export namespace UnionExplorer {
 
     export const map = (props: map.IProps) =>
         check_union_array_like<[Metadata, Metadata]>({
-            size: (input) => IdentifierFactory.join(input, "size"),
+            size: (input) => IdentifierFactory.join(input)("size"),
             front: (input) =>
                 IdentifierFactory.join(
                     ts.factory.createCallExpression(
                         IdentifierFactory.join(
                             ts.factory.createCallExpression(
-                                IdentifierFactory.join(input, "entries"),
+                                IdentifierFactory.join(input)("entries"),
                                 undefined,
                                 undefined,
                             ),
-                            "next",
-                        ),
+                        )("next"),
                         undefined,
                         undefined,
                     ),
-                    "value",
-                ),
+                )("value"),
             array: (input) =>
                 ts.factory.createArrayLiteralExpression(
                     [ts.factory.createSpreadElement(input)],

package/src/programmers/helpers/UnionPredicator.ts

@@ -13,14 +13,14 @@ export namespace UnionPredicator {
         neighbour: boolean;
     }
 
-    export function object(targets: MetadataObject[]): Array<ISpecialized> {
+    export const object = (targets: MetadataObject[]): Array<ISpecialized> => {
         // PROPERTY MATRIX
         const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
         for (const obj of targets)
             for (const prop of obj.properties) {
                 const key: string | null = prop.key.getSoleLiteral();
                 if (key !== null)
-                    MapUtil.take(matrix, key, () =>
+                    MapUtil.take(matrix)(key, () =>
                         ArrayUtil.repeat(targets.length, () => null),
                     );
             }
@@ -72,7 +72,7 @@ export namespace UnionPredicator {
             });
         });
         return output;
-    }
+    };
 }
 
 interface ISpecializedProperty {

package/src/programmers/internal/application_array.ts

@@ -12,25 +12,24 @@ export const application_array =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (tuple?: IJsonSchema.ITuple) =>
-    (
-        metadata: Metadata,
-        nullable: boolean,
-        attribute: IJsonSchema.IAttribute,
-    ): IJsonSchema.IArray => {
+    (metadata: Metadata) =>
+    (props: {
+        nullable: boolean;
+        attribute: IJsonSchema.IAttribute;
+    }): IJsonSchema.IArray => {
         // SCHEMA
         const output: IJsonSchema.IArray = {
             type: "array",
-            items: application_schema(options)(components)(false)(
-                metadata,
-                attribute,
+            items: application_schema(options)(false)(components)(metadata)(
+                props.attribute,
             ),
-            nullable,
+            nullable: props.nullable,
             "x-typia-tuple": tuple,
-            ...attribute,
+            ...props.attribute,
         };
 
         // RANGE
-        for (const tag of attribute["x-typia-metaTags"] || [])
+        for (const tag of props.attribute["x-typia-metaTags"] || [])
             if (tag.kind === "minItems") output.minItems = tag.value;
             else if (tag.kind === "maxItems") output.maxItems = tag.value;
         return output;