typia 9.7.2 → 10.0.0-dev.20251107

package/src/schemas/metadata/MetadataTemplate.ts

@@ -1,78 +1,78 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataDictionary } from "./IMetadataDictionary";
-import { IMetadataTemplate } from "./IMetadataTemplate";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { Metadata } from "./Metadata";
-
-export class MetadataTemplate {
-  public readonly row: Metadata[];
-  public readonly tags: IMetadataTypeTag[][];
-
-  private name_?: string;
-
-  private constructor(props: ClassProperties<MetadataTemplate>) {
-    this.row = props.row.map(Metadata.create);
-    this.tags = props.tags;
-  }
-
-  public static create(
-    props: ClassProperties<MetadataTemplate>,
-  ): MetadataTemplate {
-    return new MetadataTemplate(props);
-  }
-
-  public static from(
-    json: IMetadataTemplate,
-    dict: IMetadataDictionary,
-  ): MetadataTemplate {
-    return new MetadataTemplate({
-      row: json.row.map((m) => Metadata.from(m, dict)),
-      tags: json.tags,
-    });
-  }
-
-  public getName(): string {
-    return (this.name_ ??= getName(this));
-  }
-
-  /** @internal */
-  public getBaseName(): string {
-    return (
-      "`" +
-      this.row
-        .map((child) =>
-          child.isConstant() && child.size() === 1
-            ? child.constants[0]!.values[0]!.value
-            : `$\{${child.getName()}\}`,
-        )
-        .join("")
-        .split("`")
-        .join("\\`") +
-      "`"
-    );
-  }
-
-  public toJSON(): IMetadataTemplate {
-    return {
-      row: this.row.map((m) => m.toJSON()),
-      tags: this.tags,
-    };
-  }
-}
-
-const getName = (template: MetadataTemplate): string => {
-  const base: string = template.getBaseName();
-  if (!template.tags?.length) return base;
-  else if (template.tags.length === 1) {
-    const str: string = [base, ...template.tags[0]!.map((t) => t.name)].join(
-      " & ",
-    );
-    return `(${str})`;
-  }
-  const rows: string[] = template.tags.map((row) => {
-    const str: string = row.map((t) => t.name).join(" & ");
-    return row.length === 1 ? str : `(${str})`;
-  });
-  return `(${base} & (${rows.join(" | ")}))`;
-};
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataTemplate } from "./IMetadataTemplate";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { Metadata } from "./Metadata";
+
+export class MetadataTemplate {
+  public readonly row: Metadata[];
+  public readonly tags: IMetadataTypeTag[][];
+
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataTemplate>) {
+    this.row = props.row.map(Metadata.create);
+    this.tags = props.tags;
+  }
+
+  public static create(
+    props: ClassProperties<MetadataTemplate>,
+  ): MetadataTemplate {
+    return new MetadataTemplate(props);
+  }
+
+  public static from(
+    json: IMetadataTemplate,
+    dict: IMetadataDictionary,
+  ): MetadataTemplate {
+    return new MetadataTemplate({
+      row: json.row.map((m) => Metadata.from(m, dict)),
+      tags: json.tags,
+    });
+  }
+
+  public getName(): string {
+    return (this.name_ ??= getName(this));
+  }
+
+  /** @internal */
+  public getBaseName(): string {
+    return (
+      "`" +
+      this.row
+        .map((child) =>
+          child.isConstant() && child.size() === 1
+            ? child.constants[0]!.values[0]!.value
+            : `$\{${child.getName()}\}`,
+        )
+        .join("")
+        .split("`")
+        .join("\\`") +
+      "`"
+    );
+  }
+
+  public toJSON(): IMetadataTemplate {
+    return {
+      row: this.row.map((m) => m.toJSON()),
+      tags: this.tags,
+    };
+  }
+}
+
+const getName = (template: MetadataTemplate): string => {
+  const base: string = template.getBaseName();
+  if (!template.tags?.length) return base;
+  else if (template.tags.length === 1) {
+    const str: string = [base, ...template.tags[0]!.map((t) => t.name)].join(
+      " & ",
+    );
+    return `(${str})`;
+  }
+  const rows: string[] = template.tags.map((row) => {
+    const str: string = row.map((t) => t.name).join(" & ");
+    return row.length === 1 ? str : `(${str})`;
+  });
+  return `(${base} & (${rows.join(" | ")}))`;
+};

package/src/schemas/metadata/MetadataTuple.ts

@@ -1,28 +1,28 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataTuple } from "./IMetadataTuple";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { MetadataTupleType } from "./MetadataTupleType";
-
-export class MetadataTuple {
-  public readonly type: MetadataTupleType;
-  public readonly tags: IMetadataTypeTag[][];
-
-  /** @ignore */
-  private constructor(props: ClassProperties<MetadataTuple>) {
-    this.type = props.type;
-    this.tags = props.tags;
-  }
-
-  /** @internal */
-  public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
-    return new MetadataTuple(props);
-  }
-
-  public toJSON(): IMetadataTuple {
-    return {
-      name: this.type.name,
-      tags: this.tags.map((row) => row.slice()),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTuple } from "./IMetadataTuple";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataTupleType } from "./MetadataTupleType";
+
+export class MetadataTuple {
+  public readonly type: MetadataTupleType;
+  public readonly tags: IMetadataTypeTag[][];
+
+  /** @ignore */
+  private constructor(props: ClassProperties<MetadataTuple>) {
+    this.type = props.type;
+    this.tags = props.tags;
+  }
+
+  /** @internal */
+  public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
+    return new MetadataTuple(props);
+  }
+
+  public toJSON(): IMetadataTuple {
+    return {
+      name: this.type.name,
+      tags: this.tags.map((row) => row.slice()),
+    };
+  }
+}

package/src/schemas/metadata/MetadataTupleType.ts

@@ -1,61 +1,61 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataTupleType } from "./IMetadataTupleType";
-import { Metadata } from "./Metadata";
-
-export class MetadataTupleType {
-  public readonly name: string;
-  public readonly elements: Metadata[];
-
-  public readonly index: number | null;
-  public readonly recursive: boolean;
-  public readonly nullables: boolean[];
-
-  /** @internal */
-  public of_map?: boolean;
-
-  /** @internal */
-  private constructor(props: ClassProperties<MetadataTupleType>) {
-    this.name = props.name;
-    this.elements = props.elements;
-    this.index = props.index;
-    this.recursive = props.recursive;
-    this.nullables = props.nullables;
-  }
-
-  /** @internal */
-  public static _From_without_elements(
-    props: Omit<IMetadataTupleType, "elements">,
-  ): MetadataTupleType {
-    return MetadataTupleType.create({
-      name: props.name,
-      index: props.index,
-      elements: null!,
-      recursive: props.recursive,
-      nullables: props.nullables.slice(),
-    });
-  }
-
-  public static create(
-    props: ClassProperties<MetadataTupleType>,
-  ): MetadataTupleType {
-    return new MetadataTupleType(props);
-  }
-
-  public isRest(): boolean {
-    return (
-      this.elements.length > 0 &&
-      this.elements[this.elements.length - 1]!.rest !== null
-    );
-  }
-
-  public toJSON(): IMetadataTupleType {
-    return {
-      name: this.name,
-      index: this.index,
-      elements: this.elements.map((elem) => elem.toJSON()),
-      recursive: this.recursive,
-      nullables: this.nullables.slice(),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTupleType } from "./IMetadataTupleType";
+import { Metadata } from "./Metadata";
+
+export class MetadataTupleType {
+  public readonly name: string;
+  public readonly elements: Metadata[];
+
+  public readonly index: number | null;
+  public readonly recursive: boolean;
+  public readonly nullables: boolean[];
+
+  /** @internal */
+  public of_map?: boolean;
+
+  /** @internal */
+  private constructor(props: ClassProperties<MetadataTupleType>) {
+    this.name = props.name;
+    this.elements = props.elements;
+    this.index = props.index;
+    this.recursive = props.recursive;
+    this.nullables = props.nullables;
+  }
+
+  /** @internal */
+  public static _From_without_elements(
+    props: Omit<IMetadataTupleType, "elements">,
+  ): MetadataTupleType {
+    return MetadataTupleType.create({
+      name: props.name,
+      index: props.index,
+      elements: null!,
+      recursive: props.recursive,
+      nullables: props.nullables.slice(),
+    });
+  }
+
+  public static create(
+    props: ClassProperties<MetadataTupleType>,
+  ): MetadataTupleType {
+    return new MetadataTupleType(props);
+  }
+
+  public isRest(): boolean {
+    return (
+      this.elements.length > 0 &&
+      this.elements[this.elements.length - 1]!.rest !== null
+    );
+  }
+
+  public toJSON(): IMetadataTupleType {
+    return {
+      name: this.name,
+      index: this.index,
+      elements: this.elements.map((elem) => elem.toJSON()),
+      recursive: this.recursive,
+      nullables: this.nullables.slice(),
+    };
+  }
+}

package/src/tags/Constant.ts

@@ -1,47 +1,47 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Constant tag that adds title and description metadata to literal types.
- *
- * This tag enhances literal values with human-readable documentation without
- * changing their runtime type. It's particularly useful for enum-like values
- * where you want to provide context about what each value represents.
- *
- * The metadata appears in generated JSON Schema, making API documentation more
- * descriptive and helping developers understand the meaning of specific
- * constant values.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   ```typescript
- *   type Status =
- *     | Constant<"active", { title: "Active", description: "User is currently active" }>
- *     | Constant<"inactive", { title: "Inactive", description: "User account is disabled" }>
- *     | Constant<"pending", { title: "Pending", description: "Awaiting verification" }>;
- *   ```;
- *
- * @example
- *   ```typescript
- *   interface Config {
- *     debugLevel: Constant<0, { title: "Off", description: "No debug output" }>
- *               | Constant<1, { title: "Basic", description: "Basic logging" }>
- *               | Constant<2, { title: "Verbose", description: "Detailed debug info" }>;
- *   }
- *   ```;
- *
- * @template Value The literal value (boolean, number, string, or bigint)
- * @template Content Metadata with optional title and description
- */
-export type Constant<
-  Value extends boolean | number | string | bigint,
-  Content extends {
-    title?: string | undefined;
-    description?: string | undefined;
-  },
-> = Value &
-  TagBase<{
-    target: "string" | "boolean" | "number" | "bigint";
-    kind: "constant";
-    value: undefined;
-    schema: Content;
-  }>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Constant tag that adds title and description metadata to literal types.
+ *
+ * This tag enhances literal values with human-readable documentation without
+ * changing their runtime type. It's particularly useful for enum-like values
+ * where you want to provide context about what each value represents.
+ *
+ * The metadata appears in generated JSON Schema, making API documentation more
+ * descriptive and helping developers understand the meaning of specific
+ * constant values.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   type Status =
+ *     | Constant<"active", { title: "Active", description: "User is currently active" }>
+ *     | Constant<"inactive", { title: "Inactive", description: "User account is disabled" }>
+ *     | Constant<"pending", { title: "Pending", description: "Awaiting verification" }>;
+ *   ```;
+ *
+ * @example
+ *   ```typescript
+ *   interface Config {
+ *     debugLevel: Constant<0, { title: "Off", description: "No debug output" }>
+ *               | Constant<1, { title: "Basic", description: "Basic logging" }>
+ *               | Constant<2, { title: "Verbose", description: "Detailed debug info" }>;
+ *   }
+ *   ```;
+ *
+ * @template Value The literal value (boolean, number, string, or bigint)
+ * @template Content Metadata with optional title and description
+ */
+export type Constant<
+  Value extends boolean | number | string | bigint,
+  Content extends {
+    title?: string | undefined;
+    description?: string | undefined;
+  },
+> = Value &
+  TagBase<{
+    target: "string" | "boolean" | "number" | "bigint";
+    kind: "constant";
+    value: undefined;
+    schema: Content;
+  }>;

package/src/tags/ContentMediaType.ts

@@ -1,27 +1,27 @@
-import { TagBase } from "./TagBase";
-
-/**
- * String content media type constraint tag.
- *
- * Specifies the MIME type of string content for proper interpretation. This tag
- * serves as metadata to indicate how the string content should be interpreted,
- * but does not perform validation on the content itself.
- *
- * Examples: type JsonData = string & ContentMediaType<"application/json">; //
- * JSON string type Base64Image = string & ContentMediaType<"image/png">; //
- * Base64 PNG type XmlContent = string & ContentMediaType<"application/xml">; //
- * XML data
- *
- * Common MIME types: application/json, text/html, image/jpeg, image/png,
- * application/pdf, text/plain, application/xml, and many more.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export type ContentMediaType<Value extends string> = TagBase<{
-  target: "string";
-  kind: "contentMediaType";
-  value: undefined;
-  schema: {
-    contentMediaType: Value;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * String content media type constraint tag.
+ *
+ * Specifies the MIME type of string content for proper interpretation. This tag
+ * serves as metadata to indicate how the string content should be interpreted,
+ * but does not perform validation on the content itself.
+ *
+ * Examples: type JsonData = string & ContentMediaType<"application/json">; //
+ * JSON string type Base64Image = string & ContentMediaType<"image/png">; //
+ * Base64 PNG type XmlContent = string & ContentMediaType<"application/xml">; //
+ * XML data
+ *
+ * Common MIME types: application/json, text/html, image/jpeg, image/png,
+ * application/pdf, text/plain, application/xml, and many more.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type ContentMediaType<Value extends string> = TagBase<{
+  target: "string";
+  kind: "contentMediaType";
+  value: undefined;
+  schema: {
+    contentMediaType: Value;
+  };
+}>;

package/src/tags/Default.ts

@@ -1,52 +1,52 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Default value tag that specifies a default value for properties.
- *
- * When a property is not provided during validation, this tag instructs typia
- * to use the specified default value. This is useful for optional properties
- * that should have a specific fallback value.
- *
- * Supported types: boolean, bigint, number, and string primitives. Note:
- * Default values are applied during validation, not at compile time.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   ```typescript
- *   interface User {
- *     name: string;
- *     active: boolean & Default<true>;  // defaults to true if not provided
- *     retries: number & Default<3>;     // defaults to 3 if not provided
- *   }
- *   ```;
- *
- * @example
- *   ```typescript
- *   interface Config {
- *     timeout: bigint & Default<5000n>;    // defaults to 5000n
- *     prefix: string & Default<"user_">;   // defaults to "user_"
- *   }
- *   ```;
- *
- * @template Value The default value (boolean, bigint, number, or string)
- */
-export type Default<Value extends boolean | bigint | number | string> =
-  TagBase<{
-    target: Value extends boolean
-      ? "boolean"
-      : Value extends bigint
-        ? "bigint"
-        : Value extends number
-          ? "number"
-          : "string";
-    kind: "default";
-    value: Value;
-    exclusive: true;
-    schema: Value extends bigint
-      ? { default: Numeric<Value> }
-      : { default: Value };
-  }>;
-
-type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
-  ? N
-  : never;
+import { TagBase } from "./TagBase";
+
+/**
+ * Default value tag that specifies a default value for properties.
+ *
+ * When a property is not provided during validation, this tag instructs typia
+ * to use the specified default value. This is useful for optional properties
+ * that should have a specific fallback value.
+ *
+ * Supported types: boolean, bigint, number, and string primitives. Note:
+ * Default values are applied during validation, not at compile time.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   interface User {
+ *     name: string;
+ *     active: boolean & Default<true>;  // defaults to true if not provided
+ *     retries: number & Default<3>;     // defaults to 3 if not provided
+ *   }
+ *   ```;
+ *
+ * @example
+ *   ```typescript
+ *   interface Config {
+ *     timeout: bigint & Default<5000n>;    // defaults to 5000n
+ *     prefix: string & Default<"user_">;   // defaults to "user_"
+ *   }
+ *   ```;
+ *
+ * @template Value The default value (boolean, bigint, number, or string)
+ */
+export type Default<Value extends boolean | bigint | number | string> =
+  TagBase<{
+    target: Value extends boolean
+      ? "boolean"
+      : Value extends bigint
+        ? "bigint"
+        : Value extends number
+          ? "number"
+          : "string";
+    kind: "default";
+    value: Value;
+    exclusive: true;
+    schema: Value extends bigint
+      ? { default: Numeric<Value> }
+      : { default: Value };
+  }>;
+
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;