typia 4.1.7 → 4.1.8-dev.20230726

package/src/programmers/internal/stringify_regular_properties.ts

@@ -1,83 +1,83 @@
-import ts from "typescript";
-
-import { TemplateFactory } from "../../factories/TemplateFactory";
-import { ValueFactory } from "../../factories/ValueFactory";
-
-import { Metadata } from "../../metadata/Metadata";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-
-/**
- * @internal
- */
-export const stringify_regular_properties = (
-    regular: IExpressionEntry<ts.Expression>[],
-    dynamic: IExpressionEntry<ts.Expression>[],
-): ts.Expression[] => {
-    const output: ts.Expression[] = [];
-
-    regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
-    regular.forEach((entry, index) => {
-        // BASE ELEMENTS
-        const key: string = entry.key.getSoleLiteral()!;
-        const base: ts.Expression[] = [
-            ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
-            entry.expression,
-        ];
-        if (index !== regular.length - 1 || dynamic.length !== 0)
-            base.push(ts.factory.createStringLiteral(`,`));
-
-        const empty: boolean =
-            (entry.meta.isRequired() === false &&
-                entry.meta.nullable === false &&
-                entry.meta.size() === 0) ||
-            (entry.meta.functional &&
-                entry.meta.nullable === false &&
-                entry.meta.size() === 1);
-
-        if (empty === true) return;
-        else if (
-            entry.meta.isRequired() === false ||
-            entry.meta.functional === true ||
-            entry.meta.any === true
-        )
-            output.push(
-                ts.factory.createConditionalExpression(
-                    (() => {
-                        const conditions: ts.BinaryExpression[] = [];
-                        if (entry.meta.isRequired() === false || entry.meta.any)
-                            conditions.push(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createIdentifier("undefined"),
-                                    entry.input,
-                                ),
-                            );
-                        if (entry.meta.functional || entry.meta.any)
-                            conditions.push(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createStringLiteral("function"),
-                                    ValueFactory.TYPEOF(entry.input),
-                                ),
-                            );
-                        return conditions.length === 1
-                            ? conditions[0]!
-                            : conditions.reduce((x, y) =>
-                                  ts.factory.createLogicalOr(x, y),
-                              );
-                    })(),
-                    undefined,
-                    ts.factory.createStringLiteral(""),
-                    undefined,
-                    TemplateFactory.generate(base),
-                ),
-            );
-        else output.push(...base);
-    });
-    return output;
-};
-
-/**
- * @internal
- */
-const sequence = (meta: Metadata): number =>
-    meta.any || !meta.isRequired() || meta.functional ? 0 : 1;
+import ts from "typescript";
+
+import { TemplateFactory } from "../../factories/TemplateFactory";
+import { ValueFactory } from "../../factories/ValueFactory";
+
+import { Metadata } from "../../metadata/Metadata";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+
+/**
+ * @internal
+ */
+export const stringify_regular_properties = (
+    regular: IExpressionEntry<ts.Expression>[],
+    dynamic: IExpressionEntry<ts.Expression>[],
+): ts.Expression[] => {
+    const output: ts.Expression[] = [];
+
+    regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
+    regular.forEach((entry, index) => {
+        // BASE ELEMENTS
+        const key: string = entry.key.getSoleLiteral()!;
+        const base: ts.Expression[] = [
+            ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
+            entry.expression,
+        ];
+        if (index !== regular.length - 1 || dynamic.length !== 0)
+            base.push(ts.factory.createStringLiteral(`,`));
+
+        const empty: boolean =
+            (entry.meta.isRequired() === false &&
+                entry.meta.nullable === false &&
+                entry.meta.size() === 0) ||
+            (entry.meta.functional &&
+                entry.meta.nullable === false &&
+                entry.meta.size() === 1);
+
+        if (empty === true) return;
+        else if (
+            entry.meta.isRequired() === false ||
+            entry.meta.functional === true ||
+            entry.meta.any === true
+        )
+            output.push(
+                ts.factory.createConditionalExpression(
+                    (() => {
+                        const conditions: ts.BinaryExpression[] = [];
+                        if (entry.meta.isRequired() === false || entry.meta.any)
+                            conditions.push(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createIdentifier("undefined"),
+                                    entry.input,
+                                ),
+                            );
+                        if (entry.meta.functional || entry.meta.any)
+                            conditions.push(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createStringLiteral("function"),
+                                    ValueFactory.TYPEOF(entry.input),
+                                ),
+                            );
+                        return conditions.length === 1
+                            ? conditions[0]!
+                            : conditions.reduce((x, y) =>
+                                  ts.factory.createLogicalOr(x, y),
+                              );
+                    })(),
+                    undefined,
+                    ts.factory.createStringLiteral(""),
+                    undefined,
+                    TemplateFactory.generate(base),
+                ),
+            );
+        else output.push(...base);
+    });
+    return output;
+};
+
+/**
+ * @internal
+ */
+const sequence = (meta: Metadata): number =>
+    meta.any || !meta.isRequired() || meta.functional ? 0 : 1;

package/src/programmers/internal/template_to_pattern.ts

@@ -1,15 +1,15 @@
-import { Metadata } from "../../metadata/Metadata";
-
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const template_to_pattern = (top: boolean) => (template: Metadata[]) => {
-    const pattern: string = template
-        .map((meta) => metadata_to_pattern(false)(meta))
-        .join("");
-    return top ? PatternUtil.fix(pattern) : pattern;
-};
+import { Metadata } from "../../metadata/Metadata";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const template_to_pattern = (top: boolean) => (template: Metadata[]) => {
+    const pattern: string = template
+        .map((meta) => metadata_to_pattern(false)(meta))
+        .join("");
+    return top ? PatternUtil.fix(pattern) : pattern;
+};

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -1,16 +1,16 @@
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataArray } from "../../metadata/MetadataArray";
-
-export const wrap_metadata_rest_tuple = (rest: Metadata) => {
-    const wrapper: Metadata = Metadata.initialize();
-    wrapper.arrays.push(
-        MetadataArray.create({
-            name: `...${rest.getName()}`,
-            value: rest,
-            nullables: [],
-            recursive: false,
-            index: null,
-        }),
-    );
-    return wrapper;
-};
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataArray } from "../../metadata/MetadataArray";
+
+export const wrap_metadata_rest_tuple = (rest: Metadata) => {
+    const wrapper: Metadata = Metadata.initialize();
+    wrapper.arrays.push(
+        MetadataArray.create({
+            name: `...${rest.getName()}`,
+            value: rest,
+            nullables: [],
+            recursive: false,
+            index: null,
+        }),
+    );
+    return wrapper;
+};

package/src/schemas/IJsonApplication.ts

@@ -1,8 +1,8 @@
-import { IJsonComponents } from "./IJsonComponents";
-import { IJsonSchema } from "./IJsonSchema";
-
-export interface IJsonApplication {
-    schemas: IJsonSchema[];
-    components: IJsonComponents;
-    purpose: "swagger" | "ajv";
-}
+import { IJsonComponents } from "./IJsonComponents";
+import { IJsonSchema } from "./IJsonSchema";
+
+export interface IJsonApplication {
+    schemas: IJsonSchema[];
+    components: IJsonComponents;
+    purpose: "swagger" | "ajv";
+}

package/src/schemas/IJsonComponents.ts

@@ -1,33 +1,33 @@
-import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-
-import { IJsonSchema } from "./IJsonSchema";
-
-export interface IJsonComponents {
-    schemas?: Record<string, IJsonComponents.IObject | IJsonComponents.IAlias>;
-}
-export namespace IJsonComponents {
-    export interface IObject {
-        $id?: string;
-        type: "object";
-
-        /**
-         * Only when swagger mode.
-         */
-        nullable?: boolean;
-
-        properties: Record<string, IJsonSchema>;
-        patternProperties?: Record<string, IJsonSchema>;
-        additionalProperties?: IJsonSchema;
-
-        required?: string[];
-        description?: string;
-        "x-typia-jsDocTags"?: IJsDocTagInfo[];
-        "x-typia-patternProperties"?: Record<string, IJsonSchema>;
-        "x-typia-additionalProperties"?: IJsonSchema;
-    }
-
-    export type IAlias = IJsonSchema & {
-        $id?: string;
-        $recursiveAnchor?: boolean;
-    };
-}
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
+
+import { IJsonSchema } from "./IJsonSchema";
+
+export interface IJsonComponents {
+    schemas?: Record<string, IJsonComponents.IObject | IJsonComponents.IAlias>;
+}
+export namespace IJsonComponents {
+    export interface IObject {
+        $id?: string;
+        type: "object";
+
+        /**
+         * Only when swagger mode.
+         */
+        nullable?: boolean;
+
+        properties: Record<string, IJsonSchema>;
+        patternProperties?: Record<string, IJsonSchema>;
+        additionalProperties?: IJsonSchema;
+
+        required?: string[];
+        description?: string;
+        "x-typia-jsDocTags"?: IJsDocTagInfo[];
+        "x-typia-patternProperties"?: Record<string, IJsonSchema>;
+        "x-typia-additionalProperties"?: IJsonSchema;
+    }
+
+    export type IAlias = IJsonSchema & {
+        $id?: string;
+        $recursiveAnchor?: boolean;
+    };
+}

package/src/schemas/IJsonSchema.ts

@@ -1,133 +1,133 @@
-import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../metadata/IMetadataTag";
-
-import { Atomic } from "../typings/Atomic";
-
-export type IJsonSchema = IJsonSchema.Known | IJsonSchema.IUnknown;
-export namespace IJsonSchema {
-    export type Known =
-        | IEnumeration<"boolean">
-        | IEnumeration<"number">
-        | IEnumeration<"string">
-        | IBoolean
-        | IInteger
-        | INumber
-        | IString
-        | IArray
-        | ITuple
-        | IOneOf
-        | IReference
-        | INullOnly;
-
-    export interface IUnknown extends IAttribute {
-        type?: undefined;
-    }
-
-    /* -----------------------------------------------------------
-        ATOMICS
-    ----------------------------------------------------------- */
-    export interface IEnumeration<
-        Literal extends Exclude<Atomic.Literal, "bigint">,
-    > extends IAtomic<Literal> {
-        enum: Array<Atomic.Mapper[Literal]>;
-    }
-    export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
-        extends ISignificant<Literal> {
-        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"> {
-        minimum?: number;
-        maximum?: number;
-        exclusiveMinimum?: boolean;
-        exclusiveMaximum?: boolean;
-        multipleOf?: number;
-    }
-    export interface IInteger extends IAtomic<"integer"> {
-        /**
-         * @type int
-         */
-        minimum?: number;
-        /**
-         * @type int
-         */
-        maximum?: number;
-        exclusiveMinimum?: boolean;
-        exclusiveMaximum?: boolean;
-        /**
-         * @type int
-         */
-        multipleOf?: number;
-    }
-    export interface IBoolean extends IAtomic<"boolean"> {}
-
-    /* -----------------------------------------------------------
-        OBJECTS
-    ----------------------------------------------------------- */
-    export interface IArray extends ISignificant<"array"> {
-        items: IJsonSchema;
-        /**
-         * @type uint
-         */
-        minItems?: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
-        "x-typia-tuple"?: ITuple;
-    }
-    export interface ITuple extends ISignificant<"array"> {
-        items: IJsonSchema[];
-        /**
-         * @type uint
-         */
-        minItems: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
-    }
-    export interface IReference extends IAttribute {
-        $ref: string;
-    }
-    export interface INullOnly extends IAttribute {
-        type: "null";
-    }
-
-    /* -----------------------------------------------------------
-        MISCELLANEOUS
-    ----------------------------------------------------------- */
-    export interface IOneOf extends IAttribute {
-        oneOf: IJsonSchema[];
-    }
-
-    export interface ISignificant<Literal extends string> extends IAttribute {
-        type: Literal;
-
-        /**
-         * Only when swagger mode.
-         */
-        nullable?: boolean;
-    }
-    export interface IAttribute {
-        deprecated?: boolean;
-        title?: string;
-        description?: string;
-        "x-typia-metaTags"?: IMetadataTag[];
-        "x-typia-jsDocTags"?: IJsDocTagInfo[];
-        "x-typia-required"?: boolean;
-        "x-typia-optional"?: boolean;
-        "x-typia-rest"?: boolean;
-    }
-}
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../metadata/IMetadataTag";
+
+import { Atomic } from "../typings/Atomic";
+
+export type IJsonSchema = IJsonSchema.Known | IJsonSchema.IUnknown;
+export namespace IJsonSchema {
+    export type Known =
+        | IEnumeration<"boolean">
+        | IEnumeration<"number">
+        | IEnumeration<"string">
+        | IBoolean
+        | IInteger
+        | INumber
+        | IString
+        | IArray
+        | ITuple
+        | IOneOf
+        | IReference
+        | INullOnly;
+
+    export interface IUnknown extends IAttribute {
+        type?: undefined;
+    }
+
+    /* -----------------------------------------------------------
+        ATOMICS
+    ----------------------------------------------------------- */
+    export interface IEnumeration<
+        Literal extends Exclude<Atomic.Literal, "bigint">,
+    > extends IAtomic<Literal> {
+        enum: Array<Atomic.Mapper[Literal]>;
+    }
+    export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
+        extends ISignificant<Literal> {
+        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"> {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
+        multipleOf?: number;
+    }
+    export interface IInteger extends IAtomic<"integer"> {
+        /**
+         * @type int
+         */
+        minimum?: number;
+        /**
+         * @type int
+         */
+        maximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
+        /**
+         * @type int
+         */
+        multipleOf?: number;
+    }
+    export interface IBoolean extends IAtomic<"boolean"> {}
+
+    /* -----------------------------------------------------------
+        OBJECTS
+    ----------------------------------------------------------- */
+    export interface IArray extends ISignificant<"array"> {
+        items: IJsonSchema;
+        /**
+         * @type uint
+         */
+        minItems?: number;
+        /**
+         * @type uint
+         */
+        maxItems?: number;
+        "x-typia-tuple"?: ITuple;
+    }
+    export interface ITuple extends ISignificant<"array"> {
+        items: IJsonSchema[];
+        /**
+         * @type uint
+         */
+        minItems: number;
+        /**
+         * @type uint
+         */
+        maxItems?: number;
+    }
+    export interface IReference extends IAttribute {
+        $ref: string;
+    }
+    export interface INullOnly extends IAttribute {
+        type: "null";
+    }
+
+    /* -----------------------------------------------------------
+        MISCELLANEOUS
+    ----------------------------------------------------------- */
+    export interface IOneOf extends IAttribute {
+        oneOf: IJsonSchema[];
+    }
+
+    export interface ISignificant<Literal extends string> extends IAttribute {
+        type: Literal;
+
+        /**
+         * Only when swagger mode.
+         */
+        nullable?: boolean;
+    }
+    export interface IAttribute {
+        deprecated?: boolean;
+        title?: string;
+        description?: string;
+        "x-typia-metaTags"?: IMetadataTag[];
+        "x-typia-jsDocTags"?: IJsDocTagInfo[];
+        "x-typia-required"?: boolean;
+        "x-typia-optional"?: boolean;
+        "x-typia-rest"?: boolean;
+    }
+}