typia 3.4.22 → 3.4.23

package/src/programmers/ValidateProgrammer.ts

@@ -4,6 +4,7 @@ import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
 
 import { IProject } from "../transformers/IProject";
+import { ITransformOptions } from "../transformers/ITransformOptions";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
@@ -30,8 +31,8 @@ export namespace ValidateProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
-                    combiner: combine(equals)(importer),
-                    joiner: joiner(equals)(importer),
+                    combiner: combine(project.options)(equals)(importer),
+                    joiner: joiner(project.options)(equals)(importer),
                     success: ts.factory.createTrue(),
                 },
                 importer,
@@ -85,12 +86,13 @@ export namespace ValidateProgrammer {
 }
 
 const combine =
+    (options: ITransformOptions) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
     (explore: CheckerProgrammer.IExplore) => {
         if (explore.tracable === false)
             return IsProgrammer.CONFIG({
-                object: validate_object(equals)(importer),
+                object: validate_object(options)(equals)(importer),
                 numeric: true,
             }).combiner(explore);
 
@@ -131,39 +133,44 @@ const combine =
                   );
     };
 
-const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
-    check_object({
-        equals,
-        assert: false,
-        reduce: ts.factory.createLogicalAnd,
-        positive: ts.factory.createTrue(),
-        superfluous: (value) =>
-            create_report_call()(
-                ts.factory.createAdd(
-                    ts.factory.createIdentifier("path"),
-                    ts.factory.createCallExpression(
-                        importer.use("join"),
-                        undefined,
-                        [ts.factory.createIdentifier("key")],
+const validate_object =
+    (options: ITransformOptions) =>
+    (equals: boolean) =>
+    (importer: FunctionImporter) =>
+        check_object({
+            equals,
+            undefined: OptionPredicator.undefined(options),
+            assert: false,
+            reduce: ts.factory.createLogicalAnd,
+            positive: ts.factory.createTrue(),
+            superfluous: (value) =>
+                create_report_call()(
+                    ts.factory.createAdd(
+                        ts.factory.createIdentifier("path"),
+                        ts.factory.createCallExpression(
+                            importer.use("join"),
+                            undefined,
+                            [ts.factory.createIdentifier("key")],
+                        ),
                     ),
+                    "undefined",
+                    value,
                 ),
-                "undefined",
-                value,
-            ),
-        halt: (expr) =>
-            ts.factory.createLogicalOr(
-                ts.factory.createStrictEquality(
-                    ts.factory.createFalse(),
-                    ts.factory.createIdentifier("exceptionable"),
+            halt: (expr) =>
+                ts.factory.createLogicalOr(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createFalse(),
+                        ts.factory.createIdentifier("exceptionable"),
+                    ),
+                    expr,
                 ),
-                expr,
-            ),
-    });
+        });
 
 const joiner =
+    (options: ITransformOptions) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-        object: validate_object(equals)(importer),
+        object: validate_object(options)(equals)(importer),
         array: (input, arrow) =>
             check_everything(
                 ts.factory.createCallExpression(

package/src/programmers/helpers/AtomicPredicator.ts

@@ -1,15 +1,15 @@
-import { Metadata } from "../../metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace AtomicPredicator {
-    export const constant =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name);
-
-    export const template = (meta: Metadata): boolean =>
-        !ArrayUtil.has(meta.atomics, (type) => type === "string");
-}
+import { Metadata } from "../../metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace AtomicPredicator {
+    export const constant =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name);
+
+    export const template = (meta: Metadata): boolean =>
+        !ArrayUtil.has(meta.atomics, (type) => type === "string");
+}

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,31 +1,31 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-export class FunctionImporter {
-    private readonly used_: Set<string> = new Set();
-    private sequence_: number = 0;
-
-    public empty(): boolean {
-        return this.used_.size === 0;
-    }
-
-    public use(name: string): ts.Identifier {
-        this.used_.add(name);
-        return ts.factory.createIdentifier("$" + name);
-    }
-
-    public declare(modulo: ts.LeftHandSideExpression): ts.Statement[] {
-        return [...this.used_].map((name) =>
-            StatementFactory.constant(
-                "$" + name,
-                IdentifierFactory.join(modulo, name),
-            ),
-        );
-    }
-
-    public increment(): number {
-        return ++this.sequence_;
-    }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+export class FunctionImporter {
+    private readonly used_: Set<string> = new Set();
+    private sequence_: number = 0;
+
+    public empty(): boolean {
+        return this.used_.size === 0;
+    }
+
+    public use(name: string): ts.Identifier {
+        this.used_.add(name);
+        return ts.factory.createIdentifier("$" + name);
+    }
+
+    public declare(modulo: ts.LeftHandSideExpression): ts.Statement[] {
+        return [...this.used_].map((name) =>
+            StatementFactory.constant(
+                "$" + name,
+                IdentifierFactory.join(modulo, name),
+            ),
+        );
+    }
+
+    public increment(): number {
+        return ++this.sequence_;
+    }
+}

package/src/programmers/helpers/IExpressionEntry.ts

@@ -1,10 +1,10 @@
-import ts from "typescript";
-
-import { Metadata } from "../../metadata/Metadata";
-
-export interface IExpressionEntry {
-    input: ts.Expression;
-    key: Metadata;
-    meta: Metadata;
-    expression: ts.Expression;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+
+export interface IExpressionEntry {
+    input: ts.Expression;
+    key: Metadata;
+    meta: Metadata;
+    expression: ts.Expression;
+}

package/src/programmers/helpers/OptionPredicator.ts

@@ -12,4 +12,8 @@ export namespace OptionPredicator {
     export function finite(options: ITransformOptions): boolean {
         return options.finite === true;
     }
+
+    export function undefined(options: ITransformOptions): boolean {
+        return options.undefined !== false;
+    }
 }

package/src/programmers/helpers/StringifyJoinder.ts

@@ -1,111 +1,111 @@
-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) =>
-        (entries: IExpressionEntry[]): ts.Expression => {
-            // CHECK AND SORT ENTRIES
-            const regular: IExpressionEntry[] = entries.filter((entry) =>
-                entry.key.isSoleLiteral(),
-            );
-            const dynamic: IExpressionEntry[] = 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
-                    ? [
-                          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.required &&
-                    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 function array(
-        input: ts.Expression,
-        arrow: ts.ArrowFunction,
-    ): ts.Expression {
-        return TemplateFactory.generate([
-            ts.factory.createStringLiteral(`[`),
-            ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.join(input, "map"),
-                        undefined,
-                        [arrow],
-                    ),
-                    ts.factory.createIdentifier("join"),
-                ),
-                undefined,
-                [ts.factory.createStringLiteral(`,`)],
-            ),
-            ts.factory.createStringLiteral(`]`),
-        ]);
-    }
-
-    export function 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) =>
+        (entries: IExpressionEntry[]): ts.Expression => {
+            // CHECK AND SORT ENTRIES
+            const regular: IExpressionEntry[] = entries.filter((entry) =>
+                entry.key.isSoleLiteral(),
+            );
+            const dynamic: IExpressionEntry[] = 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
+                    ? [
+                          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.required &&
+                    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 function array(
+        input: ts.Expression,
+        arrow: ts.ArrowFunction,
+    ): ts.Expression {
+        return TemplateFactory.generate([
+            ts.factory.createStringLiteral(`[`),
+            ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(input, "map"),
+                        undefined,
+                        [arrow],
+                    ),
+                    ts.factory.createIdentifier("join"),
+                ),
+                undefined,
+                [ts.factory.createStringLiteral(`,`)],
+            ),
+            ts.factory.createStringLiteral(`]`),
+        ]);
+    }
+
+    export function 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,18 +1,18 @@
-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 function undefindable(meta: Metadata): boolean {
-        return (
-            meta.required === false ||
-            (meta.resolved !== null && meta.resolved.required === false)
-        );
-    }
-
-    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
-}
+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 function undefindable(meta: Metadata): boolean {
+        return (
+            meta.required === false ||
+            (meta.resolved !== null && meta.resolved.required === false)
+        );
+    }
+
+    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
+}

package/src/programmers/helpers/UnionPredicator.ts

@@ -1,81 +1,81 @@
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataObject } from "../../metadata/MetadataObject";
-import { MetadataProperty } from "../../metadata/MetadataProperty";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-import { MapUtil } from "../../utils/MapUtil";
-
-export namespace UnionPredicator {
-    export interface ISpecialized {
-        index: number;
-        object: MetadataObject;
-        property: MetadataProperty;
-        neighbour: boolean;
-    }
-
-    export function 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, () =>
-                        ArrayUtil.repeat(targets.length, () => null),
-                    );
-            }
-        targets.forEach((obj, i) => {
-            for (const prop of obj.properties) {
-                const key: string | null = prop.key.getSoleLiteral();
-                if (key !== null) matrix.get(key)![i] = prop;
-            }
-        });
-
-        // EXPLORE SPECIALIZERS
-        const output: ISpecialized[] = [];
-        targets.forEach((obj, i) => {
-            const children: ISpecializedProperty[] = [];
-            obj.properties.forEach((prop) => {
-                // MUST BE REQUIRED
-                if (prop.value.required === false) return;
-                const key: string | null = prop.key.getSoleLiteral();
-                if (key === null) return;
-
-                // FIND NEIGHBORHOOD PROPERTIES
-                const neighbors: MetadataProperty[] = matrix
-                    .get(key)!
-                    .filter(
-                        (oppo, k) => i !== k && oppo !== null,
-                    ) as MetadataProperty[];
-
-                // NO NEIGHBORHOOD
-                const unique: boolean =
-                    neighbors.length === 0 ||
-                    neighbors.every(
-                        (n) => !Metadata.intersects(prop.value, n.value, false),
-                    );
-                if (unique === true)
-                    children.push({
-                        property: prop,
-                        neighbour: neighbors.length !== 0,
-                    });
-            });
-            if (children.length === 0) return;
-
-            const top: ISpecializedProperty =
-                children.find((child) => child.property.value.isConstant()) ||
-                children[0]!;
-            output.push({
-                index: i,
-                object: obj,
-                ...top,
-            });
-        });
-        return output;
-    }
-}
-
-interface ISpecializedProperty {
-    property: MetadataProperty;
-    neighbour: boolean;
-}
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+import { MetadataProperty } from "../../metadata/MetadataProperty";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { MapUtil } from "../../utils/MapUtil";
+
+export namespace UnionPredicator {
+    export interface ISpecialized {
+        index: number;
+        object: MetadataObject;
+        property: MetadataProperty;
+        neighbour: boolean;
+    }
+
+    export function 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, () =>
+                        ArrayUtil.repeat(targets.length, () => null),
+                    );
+            }
+        targets.forEach((obj, i) => {
+            for (const prop of obj.properties) {
+                const key: string | null = prop.key.getSoleLiteral();
+                if (key !== null) matrix.get(key)![i] = prop;
+            }
+        });
+
+        // EXPLORE SPECIALIZERS
+        const output: ISpecialized[] = [];
+        targets.forEach((obj, i) => {
+            const children: ISpecializedProperty[] = [];
+            obj.properties.forEach((prop) => {
+                // MUST BE REQUIRED
+                if (prop.value.required === false) return;
+                const key: string | null = prop.key.getSoleLiteral();
+                if (key === null) return;
+
+                // FIND NEIGHBORHOOD PROPERTIES
+                const neighbors: MetadataProperty[] = matrix
+                    .get(key)!
+                    .filter(
+                        (oppo, k) => i !== k && oppo !== null,
+                    ) as MetadataProperty[];
+
+                // NO NEIGHBORHOOD
+                const unique: boolean =
+                    neighbors.length === 0 ||
+                    neighbors.every(
+                        (n) => !Metadata.intersects(prop.value, n.value, false),
+                    );
+                if (unique === true)
+                    children.push({
+                        property: prop,
+                        neighbour: neighbors.length !== 0,
+                    });
+            });
+            if (children.length === 0) return;
+
+            const top: ISpecializedProperty =
+                children.find((child) => child.property.value.isConstant()) ||
+                children[0]!;
+            output.push({
+                index: i,
+                object: obj,
+                ...top,
+            });
+        });
+        return output;
+    }
+}
+
+interface ISpecializedProperty {
+    property: MetadataProperty;
+    neighbour: boolean;
+}