typia 5.3.0-dev.20231122 → 5.3.0-dev.20231126

package/src/programmers/helpers/RandomRanger.ts

@@ -1,164 +1,164 @@
-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;
-
-      props.minimum ??= defs.minimum;
-      props.maximum ??= defs.maximum;
-      if (props.maximum < props.minimum) (props.maximum as number) += defs.gap;
-
-      return ts.factory.createCallExpression(coalesce("integer"), undefined, [
-        ExpressionFactory.number(props.minimum),
-        ExpressionFactory.number(props.maximum),
-      ]);
-    };
-  export namespace length {
-    export interface IAccessors {
-      minimum: string;
-      maximum: string;
-    }
-  }
-
-  export const number =
-    (config: number.IConfig) =>
-    (defs: IDefaults) =>
-    (tags: IMetadataTypeTag[]): ts.Expression => {
-      const range = {
-        minimum: {
-          value: getter(tags)("minimum") ?? getter(tags)("exclusiveMinimum"),
-          exclusive: getter(tags)("exclusiveMinimum") !== undefined,
-        },
-        maximum: {
-          value: getter(tags)("maximum") ?? getter(tags)("exclusiveMaximum"),
-          exclusive: getter(tags)("exclusiveMaximum") !== undefined,
-        },
-        stepper: undefined,
-        multiply: getter(tags)("multipleOf"),
-      };
-
-      //----
-      // MULTIPLIERS
-      //----
-      if (range.multiply !== undefined) {
-        const { minimum, maximum } = multiplier(defs.gap)(range)(
-          range.multiply,
-        );
-        return ts.factory.createMultiply(
-          config.transform(range.multiply),
-          config.setter([minimum, maximum]),
-        );
-      }
-
-      //----
-      // RANGE
-      //----
-      // INT
-      const integer = (value: number) => value === Math.floor(value);
-      if (config.type === "int") {
-        if (range.minimum.value !== undefined) {
-          if (range.minimum.exclusive) {
-            range.minimum.exclusive = false;
-            if (integer(range.minimum.value)) range.minimum.value += 1;
-          }
-          range.minimum.value = Math.ceil(range.minimum.value);
-        }
-        if (range.maximum.value !== undefined) {
-          if (range.maximum.exclusive) {
-            range.maximum.exclusive = false;
-            if (integer(range.maximum.value)) range.maximum.value -= 1;
-          }
-          range.maximum.value = Math.floor(range.maximum.value);
-        }
-      }
-
-      // UNSIGNED INT
-      if (config.type === "uint") {
-        if (range.minimum.value === undefined) range.minimum.value = 0;
-        else if (range.minimum.value <= 0) {
-          range.minimum.value = 0;
-          range.minimum.exclusive = false;
-        }
-      }
-
-      const minimum =
-        range.minimum.value ??
-        (range.maximum.value !== undefined
-          ? range.maximum.value - defs.gap
-          : defs.minimum);
-      const maximum =
-        range.maximum.value ??
-        (range.minimum.value !== undefined
-          ? range.minimum.value + defs.gap
-          : defs.maximum);
-      return config.setter([minimum, maximum]);
-    };
-  export namespace number {
-    export interface IConfig {
-      setter: (args: number[]) => ts.Expression;
-      transform: (value: number) => ts.Expression;
-      type: "int" | "uint" | "double";
-    }
-  }
-}
-
-const getter =
-  (tags: IMetadataTypeTag[]) =>
-  (kind: string): number | undefined => {
-    const value: bigint | number | undefined = tags.find(
-      (t) =>
-        t.kind === kind &&
-        (typeof t.value === "number" || typeof t.value === "bigint"),
-    )?.value;
-    return value !== undefined ? Number(value) : undefined;
-  };
-
-const multiplier = (gap: number) => (range: IRange) => (m: number) => {
-  const minimum: number =
-    range.minimum.value === undefined
-      ? 0
-      : (() => {
-          const x: number = m * Math.ceil(range.minimum.value / m);
-          return range.minimum.exclusive && x === range.minimum.value
-            ? x + m
-            : x;
-        })() / m;
-  const maximum: number =
-    range.maximum.value === undefined
-      ? gap
-      : (() => {
-          const y: number = m * Math.floor(range.maximum.value / m);
-          return range.maximum.exclusive && y === range.maximum.value
-            ? y - m
-            : y;
-        })() / m;
-  return { minimum, maximum };
-};
-
-interface IRange {
-  minimum: IScalar;
-  maximum: IScalar;
-}
-interface IScalar {
-  value?: undefined | number;
-  exclusive: boolean;
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+export namespace RandomRanger {
+  export interface IDefaults {
+    minimum: number;
+    maximum: number;
+    gap: number;
+  }
+
+  export const length =
+    (coalesce: (method: string) => ts.Expression) =>
+    (defs: IDefaults) =>
+    (acc: length.IAccessors) =>
+    (tags: IMetadataTypeTag[]): ts.Expression | undefined => {
+      const props = {
+        minimum: getter(tags)(acc.minimum),
+        maximum: getter(tags)(acc.maximum),
+      };
+      if (props.minimum === undefined && props.maximum === undefined)
+        return undefined;
+
+      props.minimum ??= defs.minimum;
+      props.maximum ??= defs.maximum;
+      if (props.maximum < props.minimum) (props.maximum as number) += defs.gap;
+
+      return ts.factory.createCallExpression(coalesce("integer"), undefined, [
+        ExpressionFactory.number(props.minimum),
+        ExpressionFactory.number(props.maximum),
+      ]);
+    };
+  export namespace length {
+    export interface IAccessors {
+      minimum: string;
+      maximum: string;
+    }
+  }
+
+  export const number =
+    (config: number.IConfig) =>
+    (defs: IDefaults) =>
+    (tags: IMetadataTypeTag[]): ts.Expression => {
+      const range = {
+        minimum: {
+          value: getter(tags)("minimum") ?? getter(tags)("exclusiveMinimum"),
+          exclusive: getter(tags)("exclusiveMinimum") !== undefined,
+        },
+        maximum: {
+          value: getter(tags)("maximum") ?? getter(tags)("exclusiveMaximum"),
+          exclusive: getter(tags)("exclusiveMaximum") !== undefined,
+        },
+        stepper: undefined,
+        multiply: getter(tags)("multipleOf"),
+      };
+
+      //----
+      // MULTIPLIERS
+      //----
+      if (range.multiply !== undefined) {
+        const { minimum, maximum } = multiplier(defs.gap)(range)(
+          range.multiply,
+        );
+        return ts.factory.createMultiply(
+          config.transform(range.multiply),
+          config.setter([minimum, maximum]),
+        );
+      }
+
+      //----
+      // RANGE
+      //----
+      // INT
+      const integer = (value: number) => value === Math.floor(value);
+      if (config.type === "int") {
+        if (range.minimum.value !== undefined) {
+          if (range.minimum.exclusive) {
+            range.minimum.exclusive = false;
+            if (integer(range.minimum.value)) range.minimum.value += 1;
+          }
+          range.minimum.value = Math.ceil(range.minimum.value);
+        }
+        if (range.maximum.value !== undefined) {
+          if (range.maximum.exclusive) {
+            range.maximum.exclusive = false;
+            if (integer(range.maximum.value)) range.maximum.value -= 1;
+          }
+          range.maximum.value = Math.floor(range.maximum.value);
+        }
+      }
+
+      // UNSIGNED INT
+      if (config.type === "uint") {
+        if (range.minimum.value === undefined) range.minimum.value = 0;
+        else if (range.minimum.value <= 0) {
+          range.minimum.value = 0;
+          range.minimum.exclusive = false;
+        }
+      }
+
+      const minimum =
+        range.minimum.value ??
+        (range.maximum.value !== undefined
+          ? range.maximum.value - defs.gap
+          : defs.minimum);
+      const maximum =
+        range.maximum.value ??
+        (range.minimum.value !== undefined
+          ? range.minimum.value + defs.gap
+          : defs.maximum);
+      return config.setter([minimum, maximum]);
+    };
+  export namespace number {
+    export interface IConfig {
+      setter: (args: number[]) => ts.Expression;
+      transform: (value: number) => ts.Expression;
+      type: "int" | "uint" | "double";
+    }
+  }
+}
+
+const getter =
+  (tags: IMetadataTypeTag[]) =>
+  (kind: string): number | undefined => {
+    const value: bigint | number | undefined = tags.find(
+      (t) =>
+        t.kind === kind &&
+        (typeof t.value === "number" || typeof t.value === "bigint"),
+    )?.value;
+    return value !== undefined ? Number(value) : undefined;
+  };
+
+const multiplier = (gap: number) => (range: IRange) => (m: number) => {
+  const minimum: number =
+    range.minimum.value === undefined
+      ? 0
+      : (() => {
+          const x: number = m * Math.ceil(range.minimum.value / m);
+          return range.minimum.exclusive && x === range.minimum.value
+            ? x + m
+            : x;
+        })() / m;
+  const maximum: number =
+    range.maximum.value === undefined
+      ? gap
+      : (() => {
+          const y: number = m * Math.floor(range.maximum.value / m);
+          return range.maximum.exclusive && y === range.maximum.value
+            ? y - m
+            : y;
+        })() / m;
+  return { minimum, maximum };
+};
+
+interface IRange {
+  minimum: IScalar;
+  maximum: IScalar;
+}
+interface IScalar {
+  value?: undefined | number;
+  exclusive: boolean;
+}

package/src/programmers/helpers/StringifyJoinder.ts

@@ -1,105 +1,105 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TemplateFactory } from "../../factories/TemplateFactory";
-
-import { stringify_dynamic_properties } from "../internal/stringify_dynamic_properties";
-import { stringify_regular_properties } from "../internal/stringify_regular_properties";
-import { FunctionImporter } from "./FunctionImporeter";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace StringifyJoiner {
-  export const object =
-    (importer: FunctionImporter) =>
-    (
-      _input: ts.Expression,
-      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(),
-      );
-      const expressions: ts.Expression[] = [
-        ...stringify_regular_properties(regular, dynamic),
-        ...(dynamic.length
-          ? [
-              stringify_dynamic_properties(
-                dynamic,
-                regular.map((r) => r.key.getSoleLiteral()!),
-              ),
-            ]
-          : []),
-      ];
-
-      // POP LAST COMMA, IF REQUIRED
-      const filtered: ts.Expression[] =
-        (regular.length &&
-          regular[regular.length - 1]!.meta.isRequired() &&
-          dynamic.length === 0) ||
-        (regular.length === 0 && dynamic.length)
-          ? expressions
-          : [
-              ts.factory.createCallExpression(importer.use("tail"), undefined, [
-                TemplateFactory.generate(expressions),
-              ]),
-            ];
-
-      // RETURNS WITH OBJECT BRACKET
-      return TemplateFactory.generate([
-        ts.factory.createStringLiteral(`{`),
-        ...filtered,
-        ts.factory.createStringLiteral(`}`),
-      ]);
-    };
-
-  export const array = (
-    input: ts.Expression,
-    arrow: ts.ArrowFunction,
-  ): ts.Expression =>
-    TemplateFactory.generate([
-      ts.factory.createStringLiteral(`[`),
-      ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("map"),
-            undefined,
-            [arrow],
-          ),
-          ts.factory.createIdentifier("join"),
-        ),
-        undefined,
-        [ts.factory.createStringLiteral(`,`)],
-      ),
-      ts.factory.createStringLiteral(`]`),
-    ]);
-
-  export const tuple = (
-    children: ts.Expression[],
-    rest: ts.Expression | null,
-  ): ts.Expression => {
-    if (children.length === 0) return ts.factory.createStringLiteral("[]");
-    if (rest === null && children.every((child) => ts.isStringLiteral(child)))
-      return ts.factory.createStringLiteral(
-        "[" +
-          children.map((child) => (child as ts.StringLiteral).text).join(",") +
-          "]",
-      );
-
-    const elements: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
-    children.forEach((child, i) => {
-      elements.push(child);
-      if (i !== children.length - 1)
-        elements.push(ts.factory.createStringLiteral(`,`));
-    });
-    if (rest !== null) elements.push(rest);
-
-    elements.push(ts.factory.createStringLiteral(`]`));
-    return TemplateFactory.generate(elements);
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+
+import { stringify_dynamic_properties } from "../internal/stringify_dynamic_properties";
+import { stringify_regular_properties } from "../internal/stringify_regular_properties";
+import { FunctionImporter } from "./FunctionImporeter";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace StringifyJoiner {
+  export const object =
+    (importer: FunctionImporter) =>
+    (
+      _input: ts.Expression,
+      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(),
+      );
+      const expressions: ts.Expression[] = [
+        ...stringify_regular_properties(regular, dynamic),
+        ...(dynamic.length
+          ? [
+              stringify_dynamic_properties(
+                dynamic,
+                regular.map((r) => r.key.getSoleLiteral()!),
+              ),
+            ]
+          : []),
+      ];
+
+      // POP LAST COMMA, IF REQUIRED
+      const filtered: ts.Expression[] =
+        (regular.length &&
+          regular[regular.length - 1]!.meta.isRequired() &&
+          dynamic.length === 0) ||
+        (regular.length === 0 && dynamic.length)
+          ? expressions
+          : [
+              ts.factory.createCallExpression(importer.use("tail"), undefined, [
+                TemplateFactory.generate(expressions),
+              ]),
+            ];
+
+      // RETURNS WITH OBJECT BRACKET
+      return TemplateFactory.generate([
+        ts.factory.createStringLiteral(`{`),
+        ...filtered,
+        ts.factory.createStringLiteral(`}`),
+      ]);
+    };
+
+  export const array = (
+    input: ts.Expression,
+    arrow: ts.ArrowFunction,
+  ): ts.Expression =>
+    TemplateFactory.generate([
+      ts.factory.createStringLiteral(`[`),
+      ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(input)("map"),
+            undefined,
+            [arrow],
+          ),
+          ts.factory.createIdentifier("join"),
+        ),
+        undefined,
+        [ts.factory.createStringLiteral(`,`)],
+      ),
+      ts.factory.createStringLiteral(`]`),
+    ]);
+
+  export const tuple = (
+    children: ts.Expression[],
+    rest: ts.Expression | null,
+  ): ts.Expression => {
+    if (children.length === 0) return ts.factory.createStringLiteral("[]");
+    if (rest === null && children.every((child) => ts.isStringLiteral(child)))
+      return ts.factory.createStringLiteral(
+        "[" +
+          children.map((child) => (child as ts.StringLiteral).text).join(",") +
+          "]",
+      );
+
+    const elements: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
+    children.forEach((child, i) => {
+      elements.push(child);
+      if (i !== children.length - 1)
+        elements.push(ts.factory.createStringLiteral(`,`));
+    });
+    if (rest !== null) elements.push(rest);
+
+    elements.push(ts.factory.createStringLiteral(`]`));
+    return TemplateFactory.generate(elements);
+  };
+}

package/src/programmers/helpers/StringifyPredicator.ts

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