From 4a412f2601bd4bba8f14464c026e65dec50a2106 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 8 Aug 2025 15:16:00 +0000 Subject: [PATCH 1/7] Initial plan From 5cc9571ddda4eb552dfd98462de64ce381dda661 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 8 Aug 2025 15:30:14 +0000 Subject: [PATCH 2/7] Implement kebab-case notation support core functionality Co-authored-by: samchon <13158709+samchon@users.noreply.github.com> --- src/KebabCase.ts | 119 ++++++++ src/notations.ts | 270 ++++++++++++++++++ src/transformers/CallExpressionTransformer.ts | 19 ++ src/utils/NamingConvention.ts | 107 ++++++- .../test_notation_kebab_ObjectAlias.ts | 12 + ...test_notation_validateKebab_ObjectAlias.ts | 12 + test_manual.js | 34 +++ 7 files changed, 572 insertions(+), 1 deletion(-) create mode 100644 src/KebabCase.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts create mode 100644 test/src/features/notation.kebab/test_notation_validateKebab_ObjectAlias.ts create mode 100644 test_manual.js diff --git a/src/KebabCase.ts b/src/KebabCase.ts new file mode 100644 index 00000000000..cc29b324929 --- /dev/null +++ b/src/KebabCase.ts @@ -0,0 +1,119 @@ +import { Equal } from "./typings/Equal"; +import { IsTuple } from "./typings/IsTuple"; +import { NativeClass } from "./typings/NativeClass"; +import { ValueOf } from "./typings/ValueOf"; + +/** + * Kebab case type. + * + * `KebabCase` type is a type that all keys of an object are converted to kebab case. + * + * It also erases every method property like {@link Resolved} type. + * + * @template T Target type to be kebab cased + * @author Jeongho Nam - https://github.com/samchon + */ +export type KebabCase = + Equal> extends true ? T : KebabizeMain; + +/* ----------------------------------------------------------- + OBJECT CONVERSION +----------------------------------------------------------- */ + +type KebabizeMain = T extends [never] + ? never // special trick for (jsonable | null) type + : T extends { valueOf(): boolean | bigint | number | string } + ? ValueOf + : T extends Function + ? never + : T extends object + ? KebabizeObject + : T; + +type KebabizeObject = + T extends Array + ? IsTuple extends true + ? KebabizeTuple + : KebabizeMain[] + : T extends Set + ? Set> + : T extends Map + ? Map, KebabizeMain> + : T extends WeakSet | WeakMap + ? never + : T extends NativeClass + ? T + : { + [Key in keyof T as KebabizeString]: KebabizeMain< + T[Key] + >; + }; + +/* ----------------------------------------------------------- + SPECIAL CASES +----------------------------------------------------------- */ +type KebabizeTuple = T extends [] + ? [] + : T extends [infer F] + ? [KebabizeMain] + : T extends [infer F, ...infer Rest extends readonly any[]] + ? [KebabizeMain, ...KebabizeTuple] + : T extends [(infer F)?] + ? [KebabizeMain?] + : T extends [(infer F)?, ...infer Rest extends readonly any[]] + ? [KebabizeMain?, ...KebabizeTuple] + : []; + +/* ----------------------------------------------------------- + STRING CONVERTER +----------------------------------------------------------- */ +type KebabizeString = Key extends `${infer _}` + ? KebabizeStringRepeatedly + : Key; +type KebabizeStringRepeatedly< + S extends string, + Previous extends string, +> = S extends `${infer First}${infer Second}${infer Rest}` + ? `${Hyphen}${Lowercase}${Hyphen< + First, + Second + >}${Lowercase}${KebabizeStringRepeatedly}` + : S extends `${infer First}` + ? `${Hyphen}${Lowercase}` + : ""; +type Hyphen = First extends + | UpperAlphabetic + | "" + | "-" + | "_" + ? "" + : Second extends UpperAlphabetic + ? "-" + : ""; +type UpperAlphabetic = + | "A" + | "B" + | "C" + | "D" + | "E" + | "F" + | "G" + | "H" + | "I" + | "J" + | "K" + | "L" + | "M" + | "N" + | "O" + | "P" + | "Q" + | "R" + | "S" + | "T" + | "U" + | "V" + | "W" + | "X" + | "Y" + | "Z"; \ No newline at end of file diff --git a/src/notations.ts b/src/notations.ts index fc77c31a4b2..b8fe5cfabc1 100644 --- a/src/notations.ts +++ b/src/notations.ts @@ -2,6 +2,7 @@ import { NoTransformConfigurationError } from "./transformers/NoTransformConfigu import { CamelCase } from "./CamelCase"; import { IValidation } from "./IValidation"; +import { KebabCase } from "./KebabCase"; import { PascalCase } from "./PascalCase"; import { SnakeCase } from "./SnakeCase"; import { TypeGuardError } from "./TypeGuardError"; @@ -11,6 +12,7 @@ import { TypeGuardError } from "./TypeGuardError"; - CAMEL CASE - PASCAL CASE - SNAKE CASE + - KEBAB CASE - FACTORY FUNCTIONS ============================================================== CAMEL CASE @@ -456,6 +458,154 @@ export function validateSnake(): never { return NoTransformConfigurationError("notations.validateSnake"); } +/* ----------------------------------------------------------- + KEBAB CASE +----------------------------------------------------------- */ +/** + * Convert to kebab case. + * + * Convert every property names of nested objects to follow the kebab case convention. + * + * For reference, this `typia.notations.kebab()` function does not validate the input value + * type. It just believes that the input value is following the type `T`. Therefore, + * if you can't ensure the input value type, it would be better to call one of them below: + * + * - {@link assertKebab} + * - {@link isKebab} + * - {@link validateKebab} + * + * @template T Type of the input value + * @param input Target object + * @returns Kebab case object + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function kebab(input: T): KebabCase; + +/** + * @internal + */ +export function kebab(): never { + return NoTransformConfigurationError("notations.kebab"); +} + +/** + * Converts to kebab case with type assertion. + * + * Convert every property names of nested objects to follow the kebab case convention. + * If the input value does not follow the type `T`, it throws {@link TypeGuardError}. + * + * @template T Type of the input value + * @param input Target object + * @param errorFactory Custom error factory. Default is `TypeGuardError` + * @returns Kebab case object + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function assertKebab( + input: T, + errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error), +): KebabCase; + +/** + * Converts to kebab case with type assertion. + * + * Convert every property names of nested objects to follow the kebab case convention. + * If the input value does not follow the type `T`, it throws {@link TypeGuardError}. + * + * @template T Type of the input value + * @param input Target object + * @param errorFactory Custom error factory. Default is `TypeGuardError` + * @returns Kebab case object + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function assertKebab( + input: unknown, + errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error), +): KebabCase; + +/** + * @internal + */ +export function assertKebab(): never { + return NoTransformConfigurationError("notations.assertKebab"); +} + +/** + * Converts to kebab case with type checking. + * + * Convert every property names of nested objects to follow the kebab case convention. + * If the input value does not follow the type `T`, it returns `null` value instead. + * + * @template T Type of the input value + * @param input Target object + * @returns Kebab case object when exact type, otherwise null + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function isKebab(input: T): KebabCase | null; + +/** + * Converts to kebab case with type checking. + * + * Convert every property names of nested objects to follow the kebab case convention. + * If the input value does not follow the type `T`, it returns `null` value instead. + * + * @template T Type of the input value + * @param input Target object + * @returns Kebab case object when exact type, otherwise null + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function isKebab(input: unknown): KebabCase | null; + +/** + * @internal + */ +export function isKebab(): never { + return NoTransformConfigurationError("notations.isKebab"); +} + +/** + * Converts to kebab case with type validation. + * + * Convert every property names of nested objects to follow the kebab case convention. + * If the input value does not follow the type `T`, it returns {@link IValidation.Failure} + * object. Otherwise, there's no problem on the input value, kebab cased converted data + * would be stored in the `data` property of the output {@link IValidation.Success} object. + * + * @template T Type of the input value + * @param input Target object + * @returns Validation result with kebab case object + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function validateKebab(input: T): IValidation>; + +/** + * Converts to kebab case with type validation. + * + * Convert every property names of nested objects to follow the kebab case convention. + * If the input value does not follow the type `T`, it returns {@link IValidation.Failure} + * object. Otherwise, there's no problem on the input value, kebab cased converted data + * would be stored in the `data` property of the output {@link IValidation.Success} object. + * + * @template T Type of the input value + * @param input Target object + * @returns Validation result with kebab case object + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function validateKebab(input: unknown): IValidation>; + +/** + * @internal + */ +export function validateKebab(): never { + return NoTransformConfigurationError("notations.validateKebab"); +} + /* ----------------------------------------------------------- FACTORY FUNCTIONS ----------------------------------------------------------- */ @@ -818,3 +968,123 @@ export function createValidateSnake(): ( export function createValidateSnake(): never { NoTransformConfigurationError("notations.createValidateSnake"); } + +/** + * Creates a reusable {@link kebab} function. + * + * @danger You must configure the generic argument `T` + * @returns Nothing until be configure the generic argument `T` + * @throws compile error + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createKebab(): never; + +/** + * Creates a reusable {@link kebab} function. + * + * @template T Type of the input value + * @returns A reusable `kebab` function + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createKebab(): (input: T) => KebabCase; + +/** + * @internal + */ +export function createKebab(): never { + NoTransformConfigurationError("notations.createKebab"); +} + +/** + * Creates a reusable {@link assertKebab} function. + * + * @danger You must configure the generic argument `T` + * @param errorFactory Custom error factory. Default is `TypeGuardError` + * @returns Nothing until be configure the generic argument `T` + * @throws compile error + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createAssertKebab( + errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error), +): never; + +/** + * Creates a reusable {@link assertKebab} function. + * + * @template T Type of the input value + * @param errorFactory Custom error factory. Default is `TypeGuardError` + * @returns A reusable `assertKebab` function + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createAssertKebab( + errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error), +): (input: T) => KebabCase; + +/** + * @internal + */ +export function createAssertKebab(): never { + NoTransformConfigurationError("notations.createAssertKebab"); +} + +/** + * Creates a reusable {@link isKebab} function. + * + * @danger You must configure the generic argument `T` + * @returns Nothing until be configure the generic argument `T` + * @throws compile error + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createIsKebab(): never; + +/** + * Creates a reusable {@link isKebab} function. + * + * @template T Type of the input value + * @returns A reusable `isKebab` function + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createIsKebab(): (input: T) => KebabCase | null; + +/** + * @internal + */ +export function createIsKebab(): never { + NoTransformConfigurationError("notations.createIsKebab"); +} + +/** + * Creates a reusable {@link validateKebab} function. + * + * @danger You must configure the generic argument `T` + * @returns Nothing until be configure the generic argument `T` + * @throws compile error + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createValidateKebab(): never; + +/** + * Creates a reusable {@link validateKebab} function. + * + * @template T Type of the input value + * @returns A reusable `validateKebab` function + * + * @author Jeongho Nam - https://github.com/samchon + */ +export function createValidateKebab(): ( + input: T, +) => IValidation>; + +/** + * @internal + */ +export function createValidateKebab(): never { + NoTransformConfigurationError("notations.createValidateKebab"); +} diff --git a/src/transformers/CallExpressionTransformer.ts b/src/transformers/CallExpressionTransformer.ts index dc7fbd59297..ef3a6774db9 100644 --- a/src/transformers/CallExpressionTransformer.ts +++ b/src/transformers/CallExpressionTransformer.ts @@ -519,6 +519,15 @@ const FUNCTORS: Record Task>> = { validateSnake: () => NotationValidateGeneralTransformer.transform(NamingConvention.snake), + // KEBAB + kebab: () => NotationGeneralTransformer.transform(NamingConvention.kebab), + assertKebab: () => + NotationAssertGeneralTransformer.transform(NamingConvention.kebab), + isKebab: () => + NotationIsGeneralTransformer.transform(NamingConvention.kebab), + validateKebab: () => + NotationValidateGeneralTransformer.transform(NamingConvention.kebab), + // FACTORIES createCamel: () => NotationCreateGeneralTransformer.transform(NamingConvention.camel), @@ -550,5 +559,15 @@ const FUNCTORS: Record Task>> = { NotationCreateValidateGeneralTransformer.transform( NamingConvention.snake, ), + createKebab: () => + NotationCreateGeneralTransformer.transform(NamingConvention.kebab), + createAssertKebab: () => + NotationCreateAssertGeneralTransformer.transform(NamingConvention.kebab), + createIsKebab: () => + NotationCreateIsGeneralTransformer.transform(NamingConvention.kebab), + createValidateKebab: () => + NotationCreateValidateGeneralTransformer.transform( + NamingConvention.kebab, + ), }, }; diff --git a/src/utils/NamingConvention.ts b/src/utils/NamingConvention.ts index 04be742339d..20b4671d1df 100644 --- a/src/utils/NamingConvention.ts +++ b/src/utils/NamingConvention.ts @@ -26,6 +26,31 @@ export namespace NamingConvention { : out(items.map(props.snake).join("")); }; + const unkebab = + (props: { + plain: (str: string) => string; + kebab: (str: string, index: number) => string; + }) => + (str: string): string => { + // Handle leading hyphens (preserve them as prefix) + let prefix: string = ""; + for (let i: number = 0; i < str.length; i++) { + if (str[i] === "-") prefix += "-"; + else break; + } + if (prefix.length !== 0) str = str.substring(prefix.length); + + const out = (s: string) => `${prefix}${s}`; + if (str.length === 0) return out(""); + + const items: string[] = str.split("-").filter((s) => s.length !== 0); + return items.length === 0 + ? out("") + : items.length === 1 + ? out(props.plain(items[0]!)) + : out(items.map(props.kebab).join("")); + }; + export function snake(str: string): string { if (str.length === 0) return str; @@ -33,13 +58,19 @@ export namespace NamingConvention { // eslint-disable-next-line @typescript-eslint/no-unused-vars let prefix: string = ""; for (let i: number = 0; i < str.length; i++) { - if (str[i] === "_") prefix += "_"; + if (str[i] === "_" || str[i] === "-") prefix += str[i]; else break; } if (prefix.length !== 0) str = str.substring(prefix.length); const out = (s: string) => `${prefix}${s}`; + // KEBAB CASE - convert to snake case + if (str.includes("-")) { + const items: string[] = str.split("-"); + return out(items.map((s) => s.toLowerCase()).join("_")); + } + // SNAKE CASE const items: string[] = str.split("_"); if (items.length > 1) @@ -72,6 +103,20 @@ export namespace NamingConvention { } export function camel(str: string) { + // Handle kebab-case input + if (str.includes("-")) { + return unkebab({ + plain: (str) => + str.length + ? str === str.toUpperCase() + ? str.toLocaleLowerCase() + : `${str[0]!.toLowerCase()}${str.substring(1)}` + : str, + kebab: (str, i) => + i === 0 ? str.toLowerCase() : StringUtil.capitalize(str.toLowerCase()), + })(str); + } + return unsnake({ plain: (str) => str.length @@ -85,10 +130,70 @@ export namespace NamingConvention { } export function pascal(str: string) { + // Handle kebab-case input + if (str.includes("-")) { + return unkebab({ + plain: (str) => + str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str, + kebab: StringUtil.capitalize, + })(str); + } + return unsnake({ plain: (str) => str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str, snake: StringUtil.capitalize, })(str); } + + export function kebab(str: string): string { + if (str.length === 0) return str; + + // PREFIX (handle leading hyphens and underscores) + let prefix: string = ""; + for (let i: number = 0; i < str.length; i++) { + if (str[i] === "-" || str[i] === "_") prefix += str[i]; + else break; + } + if (prefix.length !== 0) str = str.substring(prefix.length); + + const out = (s: string) => `${prefix}${s}`; + + // Handle snake_case input + if (str.includes("_")) { + const items: string[] = str.split("_"); + return out(items.map((s) => s.toLowerCase()).join("-")); + } + + // Handle kebab-case input (already kebab) + if (str.includes("-")) { + const items: string[] = str.split("-"); + return out(items.map((s) => s.toLowerCase()).join("-")); + } + + // CAMEL OR PASCAL CASE + const indexes: number[] = []; + for (let i: number = 0; i < str.length; i++) { + const code: number = str.charCodeAt(i); + if (65 <= code && code <= 90) indexes.push(i); + } + for (let i: number = indexes.length - 1; i > 0; --i) { + const now: number = indexes[i]!; + const prev: number = indexes[i - 1]!; + if (now - prev === 1) indexes.splice(i, 1); + } + if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1); + if (indexes.length === 0) return out(str.toLowerCase()); + + let ret: string = ""; + for (let i: number = 0; i < indexes.length; i++) { + const first: number = i === 0 ? 0 : indexes[i - 1]!; + const last: number = indexes[i]!; + + ret += str.substring(first, last).toLowerCase(); + ret += "-"; + } + ret += str.substring(indexes[indexes.length - 1]!).toLowerCase(); + return out(ret); + } } diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts new file mode 100644 index 00000000000..de00dc81983 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_general } from "../../internal/_test_notation_general"; +import { ObjectAlias } from "../../structures/ObjectAlias"; + +export const test_notation_kebab_ObjectAlias = (): void => + _test_notation_general("ObjectAlias")(ObjectAlias)< + typia.KebabCase + >({ + convert: (input) => typia.notations.kebab(input), + assert: typia.createAssert>(), + }); \ No newline at end of file diff --git a/test/src/features/notation.kebab/test_notation_validateKebab_ObjectAlias.ts b/test/src/features/notation.kebab/test_notation_validateKebab_ObjectAlias.ts new file mode 100644 index 00000000000..487daef6036 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_validateKebab_ObjectAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectAlias } from "../../structures/ObjectAlias"; + +export const test_notation_validateKebab_ObjectAlias = (): void => + _test_notation_validateGeneral("ObjectAlias")(ObjectAlias)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); \ No newline at end of file diff --git a/test_manual.js b/test_manual.js new file mode 100644 index 00000000000..19eba6e072e --- /dev/null +++ b/test_manual.js @@ -0,0 +1,34 @@ +const typia = require("./lib/index.js"); + +const testData = { + firstName: "John", + lastName: "Doe", + homeAddress: { + streetName: "Main Street", + zipCode: 12345 + } +}; + +console.log("Original:", JSON.stringify(testData, null, 2)); + +// Test if the kebab function was exported correctly +try { + console.log("Kebab function exists:", typeof typia.notations.kebab); + console.log("Camel function exists:", typeof typia.notations.camel); + + // Test individual naming convention functions + const NamingConvention = require("./lib/utils/NamingConvention.js"); + console.log("Testing individual kebab function:"); + console.log("firstName ->", NamingConvention.NamingConvention.kebab("firstName")); + console.log("lastName ->", NamingConvention.NamingConvention.kebab("lastName")); + console.log("homeAddress ->", NamingConvention.NamingConvention.kebab("homeAddress")); + console.log("streetName ->", NamingConvention.NamingConvention.kebab("streetName")); + console.log("zipCode ->", NamingConvention.NamingConvention.kebab("zipCode")); + + // Test reverse conversion + console.log("Testing reverse conversion:"); + console.log("first-name ->", NamingConvention.NamingConvention.camel("first-name")); + console.log("last-name ->", NamingConvention.NamingConvention.camel("last-name")); +} catch (error) { + console.error("Error:", error.message); +} \ No newline at end of file From 7a8c776e3ffd83c28dfdbd64247da3fa2584d6c2 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 8 Aug 2025 15:34:19 +0000 Subject: [PATCH 3/7] Complete kebab-case notation support with comprehensive testing Co-authored-by: samchon <13158709+samchon@users.noreply.github.com> --- .../test_notation_assertKebab_ObjectSimple.ts | 12 +++++++ .../test_notation_isKebab_ObjectSimple.ts | 12 +++++++ .../test_notation_kebab_ObjectSimple.ts | 12 +++++++ test_manual.js | 34 ------------------- 4 files changed, 36 insertions(+), 34 deletions(-) create mode 100644 test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts delete mode 100644 test_manual.js diff --git a/test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts b/test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts new file mode 100644 index 00000000000..0a7e01aae85 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_assertGeneral } from "../../internal/_test_notation_assertGeneral"; +import { ObjectSimple } from "../../structures/ObjectSimple"; + +export const test_notation_assertKebab_ObjectSimple = (): void => + _test_notation_assertGeneral("ObjectSimple")(ObjectSimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.assertKebab(input), + assert: typia.createAssert>(), + }); \ No newline at end of file diff --git a/test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts b/test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts new file mode 100644 index 00000000000..2f33923a785 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_isGeneral } from "../../internal/_test_notation_isGeneral"; +import { ObjectSimple } from "../../structures/ObjectSimple"; + +export const test_notation_isKebab_ObjectSimple = (): void => + _test_notation_isGeneral("ObjectSimple")(ObjectSimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.isKebab(input), + assert: typia.createAssert>(), + }); \ No newline at end of file diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts new file mode 100644 index 00000000000..2bfd4ed1423 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_general } from "../../internal/_test_notation_general"; +import { ObjectSimple } from "../../structures/ObjectSimple"; + +export const test_notation_kebab_ObjectSimple = (): void => + _test_notation_general("ObjectSimple")(ObjectSimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.kebab(input), + assert: typia.createAssert>(), + }); diff --git a/test_manual.js b/test_manual.js deleted file mode 100644 index 19eba6e072e..00000000000 --- a/test_manual.js +++ /dev/null @@ -1,34 +0,0 @@ -const typia = require("./lib/index.js"); - -const testData = { - firstName: "John", - lastName: "Doe", - homeAddress: { - streetName: "Main Street", - zipCode: 12345 - } -}; - -console.log("Original:", JSON.stringify(testData, null, 2)); - -// Test if the kebab function was exported correctly -try { - console.log("Kebab function exists:", typeof typia.notations.kebab); - console.log("Camel function exists:", typeof typia.notations.camel); - - // Test individual naming convention functions - const NamingConvention = require("./lib/utils/NamingConvention.js"); - console.log("Testing individual kebab function:"); - console.log("firstName ->", NamingConvention.NamingConvention.kebab("firstName")); - console.log("lastName ->", NamingConvention.NamingConvention.kebab("lastName")); - console.log("homeAddress ->", NamingConvention.NamingConvention.kebab("homeAddress")); - console.log("streetName ->", NamingConvention.NamingConvention.kebab("streetName")); - console.log("zipCode ->", NamingConvention.NamingConvention.kebab("zipCode")); - - // Test reverse conversion - console.log("Testing reverse conversion:"); - console.log("first-name ->", NamingConvention.NamingConvention.camel("first-name")); - console.log("last-name ->", NamingConvention.NamingConvention.camel("last-name")); -} catch (error) { - console.error("Error:", error.message); -} \ No newline at end of file From 5e5ee0b0d01101da538983488f2e5e0bb070447a Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 8 Aug 2025 15:36:26 +0000 Subject: [PATCH 4/7] Add KebabCase type export and usage example Co-authored-by: samchon <13158709+samchon@users.noreply.github.com> --- KEBAB_USAGE_EXAMPLE.ts | 68 ++++++++++++++++++++++++++++++++++++++++++ src/module.ts | 1 + 2 files changed, 69 insertions(+) create mode 100644 KEBAB_USAGE_EXAMPLE.ts diff --git a/KEBAB_USAGE_EXAMPLE.ts b/KEBAB_USAGE_EXAMPLE.ts new file mode 100644 index 00000000000..85ab8e980f6 --- /dev/null +++ b/KEBAB_USAGE_EXAMPLE.ts @@ -0,0 +1,68 @@ +// Example usage of kebab-case notation support in typia +import typia from "typia"; + +// Define a TypeScript interface with typical camelCase properties +interface UserProfile { + firstName: string; + lastName: string; + emailAddress: string; + phoneNumber: string; + homeAddress: { + streetName: string; + zipCode: number; + countryCode: string; + }; + personalDetails: { + birthDate: string; + socialSecurityNumber?: string; + }; +} + +// API returns data in kebab-case format (common in some REST APIs) +const apiResponse = { + "first-name": "John", + "last-name": "Doe", + "email-address": "john.doe@example.com", + "phone-number": "123-456-7890", + "home-address": { + "street-name": "Main Street", + "zip-code": 12345, + "country-code": "US" + }, + "personal-details": { + "birth-date": "1990-01-01", + "social-security-number": "123-45-6789" + } +}; + +// BEFORE kebab-case support: accessing properties was clunky +// const firstName = apiResponse["first-name"]; // string indexing required +// const streetName = apiResponse["home-address"]["street-name"]; // cumbersome + +// WITH kebab-case support: clean TypeScript conversion +const userProfile = typia.notations.kebab(apiResponse); + +// Now you can use normal property access: +// userProfile.firstName → "John" +// userProfile.emailAddress → "john.doe@example.com" +// userProfile.homeAddress.streetName → "Main Street" + +// Type-safe conversion with validation +const validatedProfile = typia.notations.validateKebab(apiResponse); +if (validatedProfile.success) { + console.log("Valid profile:", validatedProfile.data.firstName); +} else { + console.log("Validation errors:", validatedProfile.errors); +} + +// Assertion with error throwing +const assertedProfile = typia.notations.assertKebab(apiResponse); +console.log("Asserted profile email:", assertedProfile.emailAddress); + +// Type checking without transformation +const checkedProfile = typia.notations.isKebab(apiResponse); +if (checkedProfile !== null) { + console.log("Profile is valid:", checkedProfile.personalDetails.birthDate); +} + +export {}; \ No newline at end of file diff --git a/src/module.ts b/src/module.ts index 679ad5a8429..18b081057e3 100644 --- a/src/module.ts +++ b/src/module.ts @@ -30,6 +30,7 @@ export * from "./TypeGuardError"; export * from "./Primitive"; export * from "./Resolved"; export * from "./CamelCase"; +export * from "./KebabCase"; export * from "./PascalCase"; export * from "./SnakeCase"; export * from "./IReadableURLSearchParams"; From 37cf7d8c8b8213d5462bc31aeedb502ea4534e0f Mon Sep 17 00:00:00 2001 From: Jeongho Nam Date: Mon, 22 Sep 2025 00:56:36 +0900 Subject: [PATCH 5/7] complete implementation --- KEBAB_USAGE_EXAMPLE.ts | 68 ------------------- test/build/internal/TestFeature.ts | 2 +- .../test_notation_createKebab_ArrayAny.ts | 12 ++++ ...t_notation_createKebab_ArrayAtomicAlias.ts | 12 ++++ ..._notation_createKebab_ArrayAtomicSimple.ts | 12 ++++ ..._notation_createKebab_ArrayHierarchical.ts | 12 ++++ ...on_createKebab_ArrayHierarchicalPointer.ts | 15 ++++ .../test_notation_createKebab_ArrayMatrix.ts | 12 ++++ ...est_notation_createKebab_ArrayRecursive.ts | 12 ++++ ...createKebab_ArrayRecursiveUnionExplicit.ts | 17 +++++ ...ebab_ArrayRecursiveUnionExplicitPointer.ts | 19 ++++++ ...createKebab_ArrayRecursiveUnionImplicit.ts | 17 +++++ ...ation_createKebab_ArrayRepeatedNullable.ts | 15 ++++ ...ation_createKebab_ArrayRepeatedOptional.ts | 15 ++++ ...ation_createKebab_ArrayRepeatedRequired.ts | 15 ++++ ...notation_createKebab_ArrayRepeatedUnion.ts | 12 ++++ ...createKebab_ArrayRepeatedUnionWithTuple.ts | 17 +++++ .../test_notation_createKebab_ArraySimple.ts | 12 ++++ ...otation_createKebab_ArraySimpleProtobuf.ts | 12 ++++ ...createKebab_ArraySimpleProtobufNullable.ts | 17 +++++ ...createKebab_ArraySimpleProtobufOptional.ts | 17 +++++ .../test_notation_createKebab_ArrayUnion.ts | 12 ++++ .../test_notation_createKebab_AtomicAlias.ts | 12 ++++ .../test_notation_createKebab_AtomicClass.ts | 12 ++++ ...notation_createKebab_AtomicIntersection.ts | 12 ++++ .../test_notation_createKebab_AtomicSimple.ts | 12 ++++ .../test_notation_createKebab_AtomicUnion.ts | 12 ++++ .../test_notation_createKebab_ClassMethod.ts | 12 ++++ ...est_notation_createKebab_ClassNonPublic.ts | 12 ++++ ...ion_createKebab_ClassPropertyAssignment.ts | 15 ++++ ...st_notation_createKebab_CommentTagArray.ts | 12 ++++ ...tation_createKebab_CommentTagArrayUnion.ts | 15 ++++ ...ation_createKebab_CommentTagAtomicUnion.ts | 15 ++++ ...t_notation_createKebab_CommentTagBigInt.ts | 12 ++++ ..._notation_createKebab_CommentTagDefault.ts | 12 ++++ ...t_notation_createKebab_CommentTagFormat.ts | 12 ++++ ...notation_createKebab_CommentTagInfinite.ts | 12 ++++ ...t_notation_createKebab_CommentTagLength.ts | 12 ++++ ...test_notation_createKebab_CommentTagNaN.ts | 12 ++++ ...ation_createKebab_CommentTagObjectUnion.ts | 15 ++++ ..._notation_createKebab_CommentTagPattern.ts | 12 ++++ ...st_notation_createKebab_CommentTagRange.ts | 12 ++++ ...ation_createKebab_CommentTagRangeBigInt.ts | 15 ++++ ...est_notation_createKebab_CommentTagType.ts | 12 ++++ ...tation_createKebab_CommentTagTypeBigInt.ts | 15 ++++ ...tion_createKebab_ConstantAtomicAbsorbed.ts | 15 ++++ ...tation_createKebab_ConstantAtomicSimple.ts | 15 ++++ ...tation_createKebab_ConstantAtomicTagged.ts | 15 ++++ ...otation_createKebab_ConstantAtomicUnion.ts | 12 ++++ ...ation_createKebab_ConstantAtomicWrapper.ts | 15 ++++ ...on_createKebab_ConstantConstEnumeration.ts | 15 ++++ ...otation_createKebab_ConstantEnumeration.ts | 12 ++++ ...tation_createKebab_ConstantIntersection.ts | 15 ++++ ...test_notation_createKebab_InstanceUnion.ts | 12 ++++ .../test_notation_createKebab_MapAlias.ts | 12 ++++ .../test_notation_createKebab_MapSimple.ts | 12 ++++ ..._notation_createKebab_MapSimpleProtobuf.ts | 12 ++++ ...n_createKebab_MapSimpleProtobufNullable.ts | 15 ++++ ...n_createKebab_MapSimpleProtobufOptional.ts | 15 ++++ .../test_notation_createKebab_MapUnion.ts | 12 ++++ .../test_notation_createKebab_NativeSimple.ts | 12 ++++ .../test_notation_createKebab_NativeUnion.ts | 12 ++++ .../test_notation_createKebab_ObjectAlias.ts} | 6 +- .../test_notation_createKebab_ObjectDate.ts | 12 ++++ ..._notation_createKebab_ObjectDescription.ts | 12 ++++ ...test_notation_createKebab_ObjectDynamic.ts | 12 ++++ ...test_notation_createKebab_ObjectGeneric.ts | 12 ++++ ...notation_createKebab_ObjectGenericAlias.ts | 12 ++++ ...notation_createKebab_ObjectGenericArray.ts | 12 ++++ ...notation_createKebab_ObjectGenericUnion.ts | 12 ++++ ...notation_createKebab_ObjectHierarchical.ts | 12 ++++ ...st_notation_createKebab_ObjectHttpArray.ts | 12 ++++ ...t_notation_createKebab_ObjectHttpAtomic.ts | 12 ++++ ...tation_createKebab_ObjectHttpCommentTag.ts | 15 ++++ ...notation_createKebab_ObjectHttpConstant.ts | 12 ++++ ...notation_createKebab_ObjectHttpFormData.ts | 12 ++++ ...notation_createKebab_ObjectHttpNullable.ts | 12 ++++ ..._notation_createKebab_ObjectHttpTypeTag.ts | 12 ++++ ...tion_createKebab_ObjectHttpUndefindable.ts | 15 ++++ ...notation_createKebab_ObjectIntersection.ts | 12 ++++ ...test_notation_createKebab_ObjectJsonTag.ts | 12 ++++ ...ation_createKebab_ObjectLiteralProperty.ts | 15 ++++ ..._notation_createKebab_ObjectLiteralType.ts | 12 ++++ ...est_notation_createKebab_ObjectNullable.ts | 12 ++++ ...est_notation_createKebab_ObjectOptional.ts | 12 ++++ ...test_notation_createKebab_ObjectPartial.ts | 12 ++++ ...on_createKebab_ObjectPartialAndRequired.ts | 15 ++++ ...st_notation_createKebab_ObjectPrimitive.ts | 12 ++++ ...tion_createKebab_ObjectPropertyNullable.ts | 15 ++++ ...st_notation_createKebab_ObjectRecursive.ts | 12 ++++ ...est_notation_createKebab_ObjectRequired.ts | 12 ++++ ...tion_createKebab_ObjectSequenceProtobuf.ts | 15 ++++ .../test_notation_createKebab_ObjectSimple.ts | 12 ++++ ...tation_createKebab_ObjectSimpleProtobuf.ts | 15 ++++ ...reateKebab_ObjectSimpleProtobufNullable.ts | 17 +++++ ...reateKebab_ObjectSimpleProtobufOptional.ts | 17 +++++ .../test_notation_createKebab_ObjectTuple.ts | 12 ++++ ...st_notation_createKebab_ObjectUndefined.ts | 12 ++++ ...tation_createKebab_ObjectUnionComposite.ts | 15 ++++ ...createKebab_ObjectUnionCompositePointer.ts | 17 +++++ ..._notation_createKebab_ObjectUnionDouble.ts | 12 ++++ ...otation_createKebab_ObjectUnionExplicit.ts | 12 ++++ ..._createKebab_ObjectUnionExplicitPointer.ts | 16 +++++ ...otation_createKebab_ObjectUnionImplicit.ts | 12 ++++ ...n_createKebab_ObjectUnionNonPredictable.ts | 15 ++++ .../test_notation_createKebab_SetAlias.ts | 12 ++++ .../test_notation_createKebab_SetSimple.ts | 12 ++++ .../test_notation_createKebab_SetUnion.ts | 12 ++++ ...est_notation_createKebab_TemplateAtomic.ts | 12 ++++ ...t_notation_createKebab_TemplateConstant.ts | 12 ++++ ...test_notation_createKebab_TemplateUnion.ts | 12 ++++ ..._notation_createKebab_TupleHierarchical.ts | 12 ++++ ...test_notation_createKebab_TupleOptional.ts | 12 ++++ ...est_notation_createKebab_TupleRestArray.ts | 12 ++++ ...st_notation_createKebab_TupleRestAtomic.ts | 12 ++++ ...st_notation_createKebab_TupleRestObject.ts | 12 ++++ .../test_notation_createKebab_TupleUnion.ts | 12 ++++ .../test_notation_createKebab_TypeTagArray.ts | 12 ++++ ..._notation_createKebab_TypeTagArrayUnion.ts | 12 ++++ ...notation_createKebab_TypeTagAtomicUnion.ts | 12 ++++ ...test_notation_createKebab_TypeTagBigInt.ts | 12 ++++ ...test_notation_createKebab_TypeTagCustom.ts | 12 ++++ ...est_notation_createKebab_TypeTagDefault.ts | 12 ++++ ...test_notation_createKebab_TypeTagFormat.ts | 12 ++++ ...st_notation_createKebab_TypeTagInfinite.ts | 12 ++++ ...test_notation_createKebab_TypeTagLength.ts | 12 ++++ ...test_notation_createKebab_TypeTagMatrix.ts | 12 ++++ .../test_notation_createKebab_TypeTagNaN.ts | 12 ++++ ...notation_createKebab_TypeTagObjectUnion.ts | 12 ++++ ...est_notation_createKebab_TypeTagPattern.ts | 12 ++++ .../test_notation_createKebab_TypeTagRange.ts | 12 ++++ ...notation_createKebab_TypeTagRangeBigInt.ts | 12 ++++ .../test_notation_createKebab_TypeTagTuple.ts | 12 ++++ .../test_notation_createKebab_TypeTagType.ts | 12 ++++ ..._notation_createKebab_TypeTagTypeBigInt.ts | 12 ++++ ...t_notation_createKebab_TypeTagTypeUnion.ts | 12 ++++ ...test_notation_createKebab_UltimateUnion.ts | 12 ++++ .../test_notation_assertKebab_ObjectSimple.ts | 12 ---- .../test_notation_isKebab_ObjectSimple.ts | 12 ---- .../test_notation_kebab_ArrayAny.ts | 12 ++++ .../test_notation_kebab_ArrayAtomicAlias.ts | 12 ++++ .../test_notation_kebab_ArrayAtomicSimple.ts | 12 ++++ .../test_notation_kebab_ArrayHierarchical.ts | 12 ++++ ...notation_kebab_ArrayHierarchicalPointer.ts | 15 ++++ .../test_notation_kebab_ArrayMatrix.ts | 12 ++++ .../test_notation_kebab_ArrayRecursive.ts | 12 ++++ ...ation_kebab_ArrayRecursiveUnionExplicit.ts | 17 +++++ ...ebab_ArrayRecursiveUnionExplicitPointer.ts | 21 ++++++ ...ation_kebab_ArrayRecursiveUnionImplicit.ts | 17 +++++ ...st_notation_kebab_ArrayRepeatedNullable.ts | 15 ++++ ...st_notation_kebab_ArrayRepeatedOptional.ts | 15 ++++ ...st_notation_kebab_ArrayRepeatedRequired.ts | 15 ++++ .../test_notation_kebab_ArrayRepeatedUnion.ts | 13 ++++ ...ation_kebab_ArrayRepeatedUnionWithTuple.ts | 17 +++++ .../test_notation_kebab_ArraySimple.ts | 12 ++++ ...test_notation_kebab_ArraySimpleProtobuf.ts | 13 ++++ ...ation_kebab_ArraySimpleProtobufNullable.ts | 17 +++++ ...ation_kebab_ArraySimpleProtobufOptional.ts | 17 +++++ .../test_notation_kebab_ArrayUnion.ts | 12 ++++ .../test_notation_kebab_AtomicAlias.ts | 12 ++++ .../test_notation_kebab_AtomicClass.ts | 12 ++++ .../test_notation_kebab_AtomicIntersection.ts | 13 ++++ .../test_notation_kebab_AtomicSimple.ts | 12 ++++ .../test_notation_kebab_AtomicUnion.ts | 12 ++++ .../test_notation_kebab_ClassMethod.ts | 12 ++++ .../test_notation_kebab_ClassNonPublic.ts | 12 ++++ ..._notation_kebab_ClassPropertyAssignment.ts | 15 ++++ .../test_notation_kebab_CommentTagArray.ts | 12 ++++ ...est_notation_kebab_CommentTagArrayUnion.ts | 13 ++++ ...st_notation_kebab_CommentTagAtomicUnion.ts | 15 ++++ .../test_notation_kebab_CommentTagBigInt.ts | 12 ++++ .../test_notation_kebab_CommentTagDefault.ts | 12 ++++ .../test_notation_kebab_CommentTagFormat.ts | 12 ++++ .../test_notation_kebab_CommentTagInfinite.ts | 13 ++++ .../test_notation_kebab_CommentTagLength.ts | 12 ++++ .../test_notation_kebab_CommentTagNaN.ts | 12 ++++ ...st_notation_kebab_CommentTagObjectUnion.ts | 15 ++++ .../test_notation_kebab_CommentTagPattern.ts | 12 ++++ .../test_notation_kebab_CommentTagRange.ts | 12 ++++ ...st_notation_kebab_CommentTagRangeBigInt.ts | 15 ++++ .../test_notation_kebab_CommentTagType.ts | 12 ++++ ...est_notation_kebab_CommentTagTypeBigInt.ts | 13 ++++ ...t_notation_kebab_ConstantAtomicAbsorbed.ts | 15 ++++ ...est_notation_kebab_ConstantAtomicSimple.ts | 13 ++++ ...est_notation_kebab_ConstantAtomicTagged.ts | 13 ++++ ...test_notation_kebab_ConstantAtomicUnion.ts | 13 ++++ ...st_notation_kebab_ConstantAtomicWrapper.ts | 15 ++++ ...notation_kebab_ConstantConstEnumeration.ts | 15 ++++ ...test_notation_kebab_ConstantEnumeration.ts | 13 ++++ ...est_notation_kebab_ConstantIntersection.ts | 13 ++++ .../test_notation_kebab_InstanceUnion.ts | 12 ++++ .../test_notation_kebab_MapAlias.ts | 12 ++++ .../test_notation_kebab_MapSimple.ts | 12 ++++ .../test_notation_kebab_MapSimpleProtobuf.ts | 12 ++++ ...otation_kebab_MapSimpleProtobufNullable.ts | 15 ++++ ...otation_kebab_MapSimpleProtobufOptional.ts | 15 ++++ .../test_notation_kebab_MapUnion.ts | 12 ++++ .../test_notation_kebab_NativeSimple.ts | 12 ++++ .../test_notation_kebab_NativeUnion.ts | 12 ++++ .../test_notation_kebab_ObjectAlias.ts | 10 +-- .../test_notation_kebab_ObjectDate.ts | 12 ++++ .../test_notation_kebab_ObjectDescription.ts | 12 ++++ .../test_notation_kebab_ObjectDynamic.ts | 12 ++++ .../test_notation_kebab_ObjectGeneric.ts | 12 ++++ .../test_notation_kebab_ObjectGenericAlias.ts | 13 ++++ .../test_notation_kebab_ObjectGenericArray.ts | 13 ++++ .../test_notation_kebab_ObjectGenericUnion.ts | 13 ++++ .../test_notation_kebab_ObjectHierarchical.ts | 13 ++++ .../test_notation_kebab_ObjectHttpArray.ts | 12 ++++ .../test_notation_kebab_ObjectHttpAtomic.ts | 12 ++++ ...est_notation_kebab_ObjectHttpCommentTag.ts | 13 ++++ .../test_notation_kebab_ObjectHttpConstant.ts | 13 ++++ .../test_notation_kebab_ObjectHttpFormData.ts | 13 ++++ .../test_notation_kebab_ObjectHttpNullable.ts | 13 ++++ .../test_notation_kebab_ObjectHttpTypeTag.ts | 12 ++++ ...t_notation_kebab_ObjectHttpUndefindable.ts | 15 ++++ .../test_notation_kebab_ObjectIntersection.ts | 13 ++++ .../test_notation_kebab_ObjectJsonTag.ts | 12 ++++ ...st_notation_kebab_ObjectLiteralProperty.ts | 15 ++++ .../test_notation_kebab_ObjectLiteralType.ts | 12 ++++ .../test_notation_kebab_ObjectNullable.ts | 12 ++++ .../test_notation_kebab_ObjectOptional.ts | 12 ++++ .../test_notation_kebab_ObjectPartial.ts | 12 ++++ ...notation_kebab_ObjectPartialAndRequired.ts | 15 ++++ .../test_notation_kebab_ObjectPrimitive.ts | 12 ++++ ...t_notation_kebab_ObjectPropertyNullable.ts | 15 ++++ .../test_notation_kebab_ObjectRecursive.ts | 12 ++++ .../test_notation_kebab_ObjectRequired.ts | 12 ++++ ...t_notation_kebab_ObjectSequenceProtobuf.ts | 15 ++++ .../test_notation_kebab_ObjectSimple.ts | 8 +-- ...est_notation_kebab_ObjectSimpleProtobuf.ts | 13 ++++ ...tion_kebab_ObjectSimpleProtobufNullable.ts | 17 +++++ ...tion_kebab_ObjectSimpleProtobufOptional.ts | 17 +++++ .../test_notation_kebab_ObjectTuple.ts | 12 ++++ .../test_notation_kebab_ObjectUndefined.ts | 12 ++++ ...est_notation_kebab_ObjectUnionComposite.ts | 13 ++++ ...ation_kebab_ObjectUnionCompositePointer.ts | 17 +++++ .../test_notation_kebab_ObjectUnionDouble.ts | 12 ++++ ...test_notation_kebab_ObjectUnionExplicit.ts | 13 ++++ ...tation_kebab_ObjectUnionExplicitPointer.ts | 16 +++++ ...test_notation_kebab_ObjectUnionImplicit.ts | 13 ++++ ...otation_kebab_ObjectUnionNonPredictable.ts | 15 ++++ .../test_notation_kebab_SetAlias.ts | 12 ++++ .../test_notation_kebab_SetSimple.ts | 12 ++++ .../test_notation_kebab_SetUnion.ts | 12 ++++ .../test_notation_kebab_TemplateAtomic.ts | 12 ++++ .../test_notation_kebab_TemplateConstant.ts | 12 ++++ .../test_notation_kebab_TemplateUnion.ts | 12 ++++ .../test_notation_kebab_TupleHierarchical.ts | 12 ++++ .../test_notation_kebab_TupleOptional.ts | 12 ++++ .../test_notation_kebab_TupleRestArray.ts | 12 ++++ .../test_notation_kebab_TupleRestAtomic.ts | 12 ++++ .../test_notation_kebab_TupleRestObject.ts | 12 ++++ .../test_notation_kebab_TupleUnion.ts | 12 ++++ .../test_notation_kebab_TypeTagArray.ts | 12 ++++ .../test_notation_kebab_TypeTagArrayUnion.ts | 12 ++++ .../test_notation_kebab_TypeTagAtomicUnion.ts | 13 ++++ .../test_notation_kebab_TypeTagBigInt.ts | 12 ++++ .../test_notation_kebab_TypeTagCustom.ts | 12 ++++ .../test_notation_kebab_TypeTagDefault.ts | 12 ++++ .../test_notation_kebab_TypeTagFormat.ts | 12 ++++ .../test_notation_kebab_TypeTagInfinite.ts | 12 ++++ .../test_notation_kebab_TypeTagLength.ts | 12 ++++ .../test_notation_kebab_TypeTagMatrix.ts | 12 ++++ .../test_notation_kebab_TypeTagNaN.ts | 12 ++++ .../test_notation_kebab_TypeTagObjectUnion.ts | 13 ++++ .../test_notation_kebab_TypeTagPattern.ts | 12 ++++ .../test_notation_kebab_TypeTagRange.ts | 12 ++++ .../test_notation_kebab_TypeTagRangeBigInt.ts | 13 ++++ .../test_notation_kebab_TypeTagTuple.ts | 12 ++++ .../test_notation_kebab_TypeTagType.ts | 12 ++++ .../test_notation_kebab_TypeTagTypeBigInt.ts | 12 ++++ .../test_notation_kebab_TypeTagTypeUnion.ts | 12 ++++ .../test_notation_kebab_UltimateUnion.ts | 12 ++++ 274 files changed, 3486 insertions(+), 105 deletions(-) delete mode 100644 KEBAB_USAGE_EXAMPLE.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayAny.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicAlias.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicSimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchical.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchicalPointer.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayMatrix.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursive.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicit.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicitPointer.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionImplicit.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedNullable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedOptional.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedRequired.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnionWithTuple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArraySimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobuf.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufNullable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufOptional.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ArrayUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_AtomicAlias.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_AtomicClass.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_AtomicIntersection.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_AtomicSimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_AtomicUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ClassMethod.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ClassNonPublic.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ClassPropertyAssignment.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArray.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArrayUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagAtomicUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagBigInt.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagDefault.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagFormat.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagInfinite.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagLength.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagNaN.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagObjectUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagPattern.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRange.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRangeBigInt.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagType.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_CommentTagTypeBigInt.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicAbsorbed.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicSimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicTagged.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicWrapper.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantConstEnumeration.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantEnumeration.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ConstantIntersection.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_InstanceUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_MapAlias.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_MapSimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobuf.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufNullable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufOptional.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_MapUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_NativeSimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_NativeUnion.ts rename test/src/features/{notation.kebab/test_notation_validateKebab_ObjectAlias.ts => notation.createKebab/test_notation_createKebab_ObjectAlias.ts} (71%) create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectDate.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectDescription.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectDynamic.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectGeneric.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericAlias.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericArray.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHierarchical.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpArray.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpAtomic.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpCommentTag.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpConstant.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpFormData.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpNullable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpTypeTag.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpUndefindable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectIntersection.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectJsonTag.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralProperty.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralType.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectNullable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectOptional.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartial.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartialAndRequired.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectPrimitive.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectPropertyNullable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectRecursive.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectRequired.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectSequenceProtobuf.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobuf.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufNullable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufOptional.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectTuple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUndefined.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionComposite.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionCompositePointer.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionDouble.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicit.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicitPointer.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionImplicit.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionNonPredictable.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_SetAlias.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_SetSimple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_SetUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TemplateAtomic.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TemplateConstant.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TemplateUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TupleHierarchical.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TupleOptional.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TupleRestArray.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TupleRestAtomic.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TupleRestObject.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TupleUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArray.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArrayUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagAtomicUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagBigInt.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagCustom.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagDefault.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagFormat.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagInfinite.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagLength.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagMatrix.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagNaN.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagObjectUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagPattern.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRange.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRangeBigInt.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTuple.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagType.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeBigInt.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeUnion.ts create mode 100644 test/src/features/notation.createKebab/test_notation_createKebab_UltimateUnion.ts delete mode 100644 test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts delete mode 100644 test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayAny.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicAlias.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchical.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchicalPointer.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayMatrix.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRecursive.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicit.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicitPointer.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionImplicit.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedNullable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedOptional.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedRequired.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnionWithTuple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArraySimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobuf.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufNullable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufOptional.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ArrayUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_AtomicAlias.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_AtomicClass.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_AtomicIntersection.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_AtomicSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_AtomicUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ClassMethod.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ClassNonPublic.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ClassPropertyAssignment.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagArray.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagArrayUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagAtomicUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagBigInt.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagDefault.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagFormat.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagInfinite.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagLength.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagNaN.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagObjectUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagPattern.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagRange.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagRangeBigInt.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagType.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_CommentTagTypeBigInt.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicAbsorbed.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicTagged.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicWrapper.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantConstEnumeration.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantEnumeration.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ConstantIntersection.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_InstanceUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_MapAlias.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_MapSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobuf.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufNullable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufOptional.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_MapUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_NativeSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_NativeUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectDate.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectDescription.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectDynamic.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectGeneric.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectGenericAlias.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectGenericArray.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectGenericUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHierarchical.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpArray.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpAtomic.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpCommentTag.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpConstant.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpFormData.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpNullable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpTypeTag.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectHttpUndefindable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectIntersection.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectJsonTag.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralProperty.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralType.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectNullable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectOptional.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectPartial.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectPartialAndRequired.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectPrimitive.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectPropertyNullable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectRecursive.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectRequired.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectSequenceProtobuf.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobuf.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufNullable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufOptional.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectTuple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUndefined.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUnionComposite.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUnionCompositePointer.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUnionDouble.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicit.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicitPointer.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUnionImplicit.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_ObjectUnionNonPredictable.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_SetAlias.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_SetSimple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_SetUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TemplateAtomic.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TemplateConstant.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TemplateUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TupleHierarchical.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TupleOptional.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TupleRestArray.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TupleRestAtomic.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TupleRestObject.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TupleUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagArray.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagArrayUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagAtomicUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagBigInt.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagCustom.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagDefault.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagFormat.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagInfinite.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagLength.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagMatrix.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagNaN.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagObjectUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagPattern.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagRange.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagRangeBigInt.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagTuple.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagType.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeBigInt.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeUnion.ts create mode 100644 test/src/features/notation.kebab/test_notation_kebab_UltimateUnion.ts diff --git a/KEBAB_USAGE_EXAMPLE.ts b/KEBAB_USAGE_EXAMPLE.ts deleted file mode 100644 index 85ab8e980f6..00000000000 --- a/KEBAB_USAGE_EXAMPLE.ts +++ /dev/null @@ -1,68 +0,0 @@ -// Example usage of kebab-case notation support in typia -import typia from "typia"; - -// Define a TypeScript interface with typical camelCase properties -interface UserProfile { - firstName: string; - lastName: string; - emailAddress: string; - phoneNumber: string; - homeAddress: { - streetName: string; - zipCode: number; - countryCode: string; - }; - personalDetails: { - birthDate: string; - socialSecurityNumber?: string; - }; -} - -// API returns data in kebab-case format (common in some REST APIs) -const apiResponse = { - "first-name": "John", - "last-name": "Doe", - "email-address": "john.doe@example.com", - "phone-number": "123-456-7890", - "home-address": { - "street-name": "Main Street", - "zip-code": 12345, - "country-code": "US" - }, - "personal-details": { - "birth-date": "1990-01-01", - "social-security-number": "123-45-6789" - } -}; - -// BEFORE kebab-case support: accessing properties was clunky -// const firstName = apiResponse["first-name"]; // string indexing required -// const streetName = apiResponse["home-address"]["street-name"]; // cumbersome - -// WITH kebab-case support: clean TypeScript conversion -const userProfile = typia.notations.kebab(apiResponse); - -// Now you can use normal property access: -// userProfile.firstName → "John" -// userProfile.emailAddress → "john.doe@example.com" -// userProfile.homeAddress.streetName → "Main Street" - -// Type-safe conversion with validation -const validatedProfile = typia.notations.validateKebab(apiResponse); -if (validatedProfile.success) { - console.log("Valid profile:", validatedProfile.data.firstName); -} else { - console.log("Validation errors:", validatedProfile.errors); -} - -// Assertion with error throwing -const assertedProfile = typia.notations.assertKebab(apiResponse); -console.log("Asserted profile email:", assertedProfile.emailAddress); - -// Type checking without transformation -const checkedProfile = typia.notations.isKebab(apiResponse); -if (checkedProfile !== null) { - console.log("Profile is valid:", checkedProfile.personalDetails.birthDate); -} - -export {}; \ No newline at end of file diff --git a/test/build/internal/TestFeature.ts b/test/build/internal/TestFeature.ts index dc8a53d82dd..e0f8a14d868 100644 --- a/test/build/internal/TestFeature.ts +++ b/test/build/internal/TestFeature.ts @@ -403,7 +403,7 @@ export namespace TestFeature { //---- // NOTATIONS //---- - ...["camel", "pascal", "snake"] + ...["camel", "kebab", "pascal", "snake"] .map((method) => ([null, "assert", "is", "validate"] as const).map((mode) => ({ module: "notation", diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAny.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAny.ts new file mode 100644 index 00000000000..0453548127c --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAny.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayAny } from "../../structures/ArrayAny"; + +export const test_notation_createValidateKebab_ArrayAny = (): void => + _test_notation_validateGeneral("ArrayAny")(ArrayAny)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicAlias.ts new file mode 100644 index 00000000000..2d979bf1fc3 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayAtomicAlias } from "../../structures/ArrayAtomicAlias"; + +export const test_notation_createValidateKebab_ArrayAtomicAlias = (): void => + _test_notation_validateGeneral("ArrayAtomicAlias")( + ArrayAtomicAlias, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicSimple.ts new file mode 100644 index 00000000000..72c374cfd11 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayAtomicSimple } from "../../structures/ArrayAtomicSimple"; + +export const test_notation_createValidateKebab_ArrayAtomicSimple = (): void => + _test_notation_validateGeneral("ArrayAtomicSimple")( + ArrayAtomicSimple, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchical.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchical.ts new file mode 100644 index 00000000000..4f8e315b9c1 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchical.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayHierarchical } from "../../structures/ArrayHierarchical"; + +export const test_notation_createValidateKebab_ArrayHierarchical = (): void => + _test_notation_validateGeneral("ArrayHierarchical")( + ArrayHierarchical, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchicalPointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchicalPointer.ts new file mode 100644 index 00000000000..74d4b6ba7c7 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchicalPointer.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayHierarchicalPointer } from "../../structures/ArrayHierarchicalPointer"; + +export const test_notation_createValidateKebab_ArrayHierarchicalPointer = + (): void => + _test_notation_validateGeneral( + "ArrayHierarchicalPointer", + )(ArrayHierarchicalPointer)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayMatrix.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayMatrix.ts new file mode 100644 index 00000000000..ac1f1a1d275 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayMatrix.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayMatrix } from "../../structures/ArrayMatrix"; + +export const test_notation_createValidateKebab_ArrayMatrix = (): void => + _test_notation_validateGeneral("ArrayMatrix")(ArrayMatrix)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursive.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursive.ts new file mode 100644 index 00000000000..c8a7a8b7a12 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursive.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursive } from "../../structures/ArrayRecursive"; + +export const test_notation_createValidateKebab_ArrayRecursive = (): void => + _test_notation_validateGeneral("ArrayRecursive")( + ArrayRecursive, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicit.ts new file mode 100644 index 00000000000..5fc412c931f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicit.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursiveUnionExplicit } from "../../structures/ArrayRecursiveUnionExplicit"; + +export const test_notation_createValidateKebab_ArrayRecursiveUnionExplicit = + (): void => + _test_notation_validateGeneral( + "ArrayRecursiveUnionExplicit", + )(ArrayRecursiveUnionExplicit)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicitPointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicitPointer.ts new file mode 100644 index 00000000000..630e2623df3 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicitPointer.ts @@ -0,0 +1,19 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursiveUnionExplicitPointer } from "../../structures/ArrayRecursiveUnionExplicitPointer"; + +export const test_notation_createValidateKebab_ArrayRecursiveUnionExplicitPointer = + (): void => + _test_notation_validateGeneral( + "ArrayRecursiveUnionExplicitPointer", + )(ArrayRecursiveUnionExplicitPointer)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert< + typia.KebabCase + >(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionImplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionImplicit.ts new file mode 100644 index 00000000000..7826aedcf3f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionImplicit.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursiveUnionImplicit } from "../../structures/ArrayRecursiveUnionImplicit"; + +export const test_notation_createValidateKebab_ArrayRecursiveUnionImplicit = + (): void => + _test_notation_validateGeneral( + "ArrayRecursiveUnionImplicit", + )(ArrayRecursiveUnionImplicit)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedNullable.ts new file mode 100644 index 00000000000..0255521c5a9 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedNullable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedNullable } from "../../structures/ArrayRepeatedNullable"; + +export const test_notation_createValidateKebab_ArrayRepeatedNullable = + (): void => + _test_notation_validateGeneral( + "ArrayRepeatedNullable", + )(ArrayRepeatedNullable)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedOptional.ts new file mode 100644 index 00000000000..6b05e92320f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedOptional.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedOptional } from "../../structures/ArrayRepeatedOptional"; + +export const test_notation_createValidateKebab_ArrayRepeatedOptional = + (): void => + _test_notation_validateGeneral( + "ArrayRepeatedOptional", + )(ArrayRepeatedOptional)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedRequired.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedRequired.ts new file mode 100644 index 00000000000..a60332bf901 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedRequired.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedRequired } from "../../structures/ArrayRepeatedRequired"; + +export const test_notation_createValidateKebab_ArrayRepeatedRequired = + (): void => + _test_notation_validateGeneral( + "ArrayRepeatedRequired", + )(ArrayRepeatedRequired)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnion.ts new file mode 100644 index 00000000000..d1981d7bdb5 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedUnion } from "../../structures/ArrayRepeatedUnion"; + +export const test_notation_createValidateKebab_ArrayRepeatedUnion = (): void => + _test_notation_validateGeneral("ArrayRepeatedUnion")( + ArrayRepeatedUnion, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnionWithTuple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnionWithTuple.ts new file mode 100644 index 00000000000..1c4f7f525c9 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnionWithTuple.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedUnionWithTuple } from "../../structures/ArrayRepeatedUnionWithTuple"; + +export const test_notation_createValidateKebab_ArrayRepeatedUnionWithTuple = + (): void => + _test_notation_validateGeneral( + "ArrayRepeatedUnionWithTuple", + )(ArrayRepeatedUnionWithTuple)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimple.ts new file mode 100644 index 00000000000..52b3a3b5ed5 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimple } from "../../structures/ArraySimple"; + +export const test_notation_createValidateKebab_ArraySimple = (): void => + _test_notation_validateGeneral("ArraySimple")(ArraySimple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobuf.ts new file mode 100644 index 00000000000..bcd9f2a3e79 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobuf.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimpleProtobuf } from "../../structures/ArraySimpleProtobuf"; + +export const test_notation_createValidateKebab_ArraySimpleProtobuf = (): void => + _test_notation_validateGeneral("ArraySimpleProtobuf")( + ArraySimpleProtobuf, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufNullable.ts new file mode 100644 index 00000000000..e9a51224b70 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufNullable.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimpleProtobufNullable } from "../../structures/ArraySimpleProtobufNullable"; + +export const test_notation_createValidateKebab_ArraySimpleProtobufNullable = + (): void => + _test_notation_validateGeneral( + "ArraySimpleProtobufNullable", + )(ArraySimpleProtobufNullable)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufOptional.ts new file mode 100644 index 00000000000..73607829f11 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufOptional.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimpleProtobufOptional } from "../../structures/ArraySimpleProtobufOptional"; + +export const test_notation_createValidateKebab_ArraySimpleProtobufOptional = + (): void => + _test_notation_validateGeneral( + "ArraySimpleProtobufOptional", + )(ArraySimpleProtobufOptional)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayUnion.ts new file mode 100644 index 00000000000..8d6c4e9a7a1 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayUnion } from "../../structures/ArrayUnion"; + +export const test_notation_createValidateKebab_ArrayUnion = (): void => + _test_notation_validateGeneral("ArrayUnion")(ArrayUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicAlias.ts new file mode 100644 index 00000000000..b64cbbb0d93 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicAlias } from "../../structures/AtomicAlias"; + +export const test_notation_createValidateKebab_AtomicAlias = (): void => + _test_notation_validateGeneral("AtomicAlias")(AtomicAlias)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicClass.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicClass.ts new file mode 100644 index 00000000000..014bfb3a6e6 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicClass.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicClass } from "../../structures/AtomicClass"; + +export const test_notation_createValidateKebab_AtomicClass = (): void => + _test_notation_validateGeneral("AtomicClass")(AtomicClass)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicIntersection.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicIntersection.ts new file mode 100644 index 00000000000..896ae41d296 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicIntersection.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicIntersection } from "../../structures/AtomicIntersection"; + +export const test_notation_createValidateKebab_AtomicIntersection = (): void => + _test_notation_validateGeneral("AtomicIntersection")( + AtomicIntersection, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicSimple.ts new file mode 100644 index 00000000000..763a39e9c4c --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicSimple } from "../../structures/AtomicSimple"; + +export const test_notation_createValidateKebab_AtomicSimple = (): void => + _test_notation_validateGeneral("AtomicSimple")(AtomicSimple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicUnion.ts new file mode 100644 index 00000000000..a7b8b3cbcff --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicUnion } from "../../structures/AtomicUnion"; + +export const test_notation_createValidateKebab_AtomicUnion = (): void => + _test_notation_validateGeneral("AtomicUnion")(AtomicUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ClassMethod.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ClassMethod.ts new file mode 100644 index 00000000000..f5ea855ff22 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ClassMethod.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ClassMethod } from "../../structures/ClassMethod"; + +export const test_notation_createValidateKebab_ClassMethod = (): void => + _test_notation_validateGeneral("ClassMethod")(ClassMethod)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ClassNonPublic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ClassNonPublic.ts new file mode 100644 index 00000000000..8eddb6b74b8 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ClassNonPublic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ClassNonPublic } from "../../structures/ClassNonPublic"; + +export const test_notation_createValidateKebab_ClassNonPublic = (): void => + _test_notation_validateGeneral("ClassNonPublic")( + ClassNonPublic, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ClassPropertyAssignment.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ClassPropertyAssignment.ts new file mode 100644 index 00000000000..0b3d5c5b49b --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ClassPropertyAssignment.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ClassPropertyAssignment } from "../../structures/ClassPropertyAssignment"; + +export const test_notation_createValidateKebab_ClassPropertyAssignment = + (): void => + _test_notation_validateGeneral( + "ClassPropertyAssignment", + )(ClassPropertyAssignment)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArray.ts new file mode 100644 index 00000000000..98575a30d57 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagArray } from "../../structures/CommentTagArray"; + +export const test_notation_createValidateKebab_CommentTagArray = (): void => + _test_notation_validateGeneral("CommentTagArray")( + CommentTagArray, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArrayUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArrayUnion.ts new file mode 100644 index 00000000000..03b2f3913ac --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArrayUnion.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagArrayUnion } from "../../structures/CommentTagArrayUnion"; + +export const test_notation_createValidateKebab_CommentTagArrayUnion = + (): void => + _test_notation_validateGeneral( + "CommentTagArrayUnion", + )(CommentTagArrayUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagAtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagAtomicUnion.ts new file mode 100644 index 00000000000..c4e63d2efa3 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagAtomicUnion.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagAtomicUnion } from "../../structures/CommentTagAtomicUnion"; + +export const test_notation_createValidateKebab_CommentTagAtomicUnion = + (): void => + _test_notation_validateGeneral( + "CommentTagAtomicUnion", + )(CommentTagAtomicUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagBigInt.ts new file mode 100644 index 00000000000..f3540ea9484 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagBigInt.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagBigInt } from "../../structures/CommentTagBigInt"; + +export const test_notation_createValidateKebab_CommentTagBigInt = (): void => + _test_notation_validateGeneral("CommentTagBigInt")( + CommentTagBigInt, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagDefault.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagDefault.ts new file mode 100644 index 00000000000..9195585deeb --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagDefault.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagDefault } from "../../structures/CommentTagDefault"; + +export const test_notation_createValidateKebab_CommentTagDefault = (): void => + _test_notation_validateGeneral("CommentTagDefault")( + CommentTagDefault, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagFormat.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagFormat.ts new file mode 100644 index 00000000000..f532def4a33 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagFormat.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagFormat } from "../../structures/CommentTagFormat"; + +export const test_notation_createValidateKebab_CommentTagFormat = (): void => + _test_notation_validateGeneral("CommentTagFormat")( + CommentTagFormat, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagInfinite.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagInfinite.ts new file mode 100644 index 00000000000..71732180e56 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagInfinite.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagInfinite } from "../../structures/CommentTagInfinite"; + +export const test_notation_createValidateKebab_CommentTagInfinite = (): void => + _test_notation_validateGeneral("CommentTagInfinite")( + CommentTagInfinite, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagLength.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagLength.ts new file mode 100644 index 00000000000..1c94a35b86b --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagLength.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagLength } from "../../structures/CommentTagLength"; + +export const test_notation_createValidateKebab_CommentTagLength = (): void => + _test_notation_validateGeneral("CommentTagLength")( + CommentTagLength, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagNaN.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagNaN.ts new file mode 100644 index 00000000000..205195a4387 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagNaN.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagNaN } from "../../structures/CommentTagNaN"; + +export const test_notation_createValidateKebab_CommentTagNaN = (): void => + _test_notation_validateGeneral("CommentTagNaN")(CommentTagNaN)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagObjectUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagObjectUnion.ts new file mode 100644 index 00000000000..abacd78c441 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagObjectUnion.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagObjectUnion } from "../../structures/CommentTagObjectUnion"; + +export const test_notation_createValidateKebab_CommentTagObjectUnion = + (): void => + _test_notation_validateGeneral( + "CommentTagObjectUnion", + )(CommentTagObjectUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagPattern.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagPattern.ts new file mode 100644 index 00000000000..eaf4759801f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagPattern.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagPattern } from "../../structures/CommentTagPattern"; + +export const test_notation_createValidateKebab_CommentTagPattern = (): void => + _test_notation_validateGeneral("CommentTagPattern")( + CommentTagPattern, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRange.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRange.ts new file mode 100644 index 00000000000..84e544579b7 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRange.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagRange } from "../../structures/CommentTagRange"; + +export const test_notation_createValidateKebab_CommentTagRange = (): void => + _test_notation_validateGeneral("CommentTagRange")( + CommentTagRange, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRangeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRangeBigInt.ts new file mode 100644 index 00000000000..c8e62b7a4a0 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRangeBigInt.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagRangeBigInt } from "../../structures/CommentTagRangeBigInt"; + +export const test_notation_createValidateKebab_CommentTagRangeBigInt = + (): void => + _test_notation_validateGeneral( + "CommentTagRangeBigInt", + )(CommentTagRangeBigInt)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagType.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagType.ts new file mode 100644 index 00000000000..9fc664af99f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagType.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagType } from "../../structures/CommentTagType"; + +export const test_notation_createValidateKebab_CommentTagType = (): void => + _test_notation_validateGeneral("CommentTagType")( + CommentTagType, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagTypeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagTypeBigInt.ts new file mode 100644 index 00000000000..9687e99f159 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagTypeBigInt.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagTypeBigInt } from "../../structures/CommentTagTypeBigInt"; + +export const test_notation_createValidateKebab_CommentTagTypeBigInt = + (): void => + _test_notation_validateGeneral( + "CommentTagTypeBigInt", + )(CommentTagTypeBigInt)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicAbsorbed.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicAbsorbed.ts new file mode 100644 index 00000000000..5521b03269e --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicAbsorbed.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicAbsorbed } from "../../structures/ConstantAtomicAbsorbed"; + +export const test_notation_createValidateKebab_ConstantAtomicAbsorbed = + (): void => + _test_notation_validateGeneral( + "ConstantAtomicAbsorbed", + )(ConstantAtomicAbsorbed)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicSimple.ts new file mode 100644 index 00000000000..e35b07869a8 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicSimple.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicSimple } from "../../structures/ConstantAtomicSimple"; + +export const test_notation_createValidateKebab_ConstantAtomicSimple = + (): void => + _test_notation_validateGeneral( + "ConstantAtomicSimple", + )(ConstantAtomicSimple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicTagged.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicTagged.ts new file mode 100644 index 00000000000..ccff60a336d --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicTagged.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicTagged } from "../../structures/ConstantAtomicTagged"; + +export const test_notation_createValidateKebab_ConstantAtomicTagged = + (): void => + _test_notation_validateGeneral( + "ConstantAtomicTagged", + )(ConstantAtomicTagged)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicUnion.ts new file mode 100644 index 00000000000..57c7c5557dd --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicUnion } from "../../structures/ConstantAtomicUnion"; + +export const test_notation_createValidateKebab_ConstantAtomicUnion = (): void => + _test_notation_validateGeneral("ConstantAtomicUnion")( + ConstantAtomicUnion, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicWrapper.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicWrapper.ts new file mode 100644 index 00000000000..0cef32d0181 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicWrapper.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicWrapper } from "../../structures/ConstantAtomicWrapper"; + +export const test_notation_createValidateKebab_ConstantAtomicWrapper = + (): void => + _test_notation_validateGeneral( + "ConstantAtomicWrapper", + )(ConstantAtomicWrapper)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantConstEnumeration.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantConstEnumeration.ts new file mode 100644 index 00000000000..290c390bfe0 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantConstEnumeration.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantConstEnumeration } from "../../structures/ConstantConstEnumeration"; + +export const test_notation_createValidateKebab_ConstantConstEnumeration = + (): void => + _test_notation_validateGeneral( + "ConstantConstEnumeration", + )(ConstantConstEnumeration)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantEnumeration.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantEnumeration.ts new file mode 100644 index 00000000000..6bcd1853a6e --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantEnumeration.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantEnumeration } from "../../structures/ConstantEnumeration"; + +export const test_notation_createValidateKebab_ConstantEnumeration = (): void => + _test_notation_validateGeneral("ConstantEnumeration")( + ConstantEnumeration, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantIntersection.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantIntersection.ts new file mode 100644 index 00000000000..2aba18073bc --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantIntersection.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantIntersection } from "../../structures/ConstantIntersection"; + +export const test_notation_createValidateKebab_ConstantIntersection = + (): void => + _test_notation_validateGeneral( + "ConstantIntersection", + )(ConstantIntersection)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_InstanceUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_InstanceUnion.ts new file mode 100644 index 00000000000..807458d7b29 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_InstanceUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { InstanceUnion } from "../../structures/InstanceUnion"; + +export const test_notation_createValidateKebab_InstanceUnion = (): void => + _test_notation_validateGeneral("InstanceUnion")(InstanceUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapAlias.ts new file mode 100644 index 00000000000..fbf9035152d --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapAlias } from "../../structures/MapAlias"; + +export const test_notation_createValidateKebab_MapAlias = (): void => + _test_notation_validateGeneral("MapAlias")(MapAlias)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimple.ts new file mode 100644 index 00000000000..5ffaa8cdc1a --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimple } from "../../structures/MapSimple"; + +export const test_notation_createValidateKebab_MapSimple = (): void => + _test_notation_validateGeneral("MapSimple")(MapSimple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobuf.ts new file mode 100644 index 00000000000..dfb1828a2e3 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobuf.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimpleProtobuf } from "../../structures/MapSimpleProtobuf"; + +export const test_notation_createValidateKebab_MapSimpleProtobuf = (): void => + _test_notation_validateGeneral("MapSimpleProtobuf")( + MapSimpleProtobuf, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufNullable.ts new file mode 100644 index 00000000000..b98228ee8d6 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufNullable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimpleProtobufNullable } from "../../structures/MapSimpleProtobufNullable"; + +export const test_notation_createValidateKebab_MapSimpleProtobufNullable = + (): void => + _test_notation_validateGeneral( + "MapSimpleProtobufNullable", + )(MapSimpleProtobufNullable)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufOptional.ts new file mode 100644 index 00000000000..0f2b155c193 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufOptional.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimpleProtobufOptional } from "../../structures/MapSimpleProtobufOptional"; + +export const test_notation_createValidateKebab_MapSimpleProtobufOptional = + (): void => + _test_notation_validateGeneral( + "MapSimpleProtobufOptional", + )(MapSimpleProtobufOptional)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapUnion.ts new file mode 100644 index 00000000000..c93bb479214 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapUnion } from "../../structures/MapUnion"; + +export const test_notation_createValidateKebab_MapUnion = (): void => + _test_notation_validateGeneral("MapUnion")(MapUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_NativeSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_NativeSimple.ts new file mode 100644 index 00000000000..33ab0a56a36 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_NativeSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { NativeSimple } from "../../structures/NativeSimple"; + +export const test_notation_createValidateKebab_NativeSimple = (): void => + _test_notation_validateGeneral("NativeSimple")(NativeSimple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_NativeUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_NativeUnion.ts new file mode 100644 index 00000000000..4cf8b3e6349 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_NativeUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { NativeUnion } from "../../structures/NativeUnion"; + +export const test_notation_createValidateKebab_NativeUnion = (): void => + _test_notation_validateGeneral("NativeUnion")(NativeUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_validateKebab_ObjectAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectAlias.ts similarity index 71% rename from test/src/features/notation.kebab/test_notation_validateKebab_ObjectAlias.ts rename to test/src/features/notation.createKebab/test_notation_createKebab_ObjectAlias.ts index 487daef6036..4563b1192a7 100644 --- a/test/src/features/notation.kebab/test_notation_validateKebab_ObjectAlias.ts +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectAlias.ts @@ -3,10 +3,10 @@ import typia from "typia"; import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; import { ObjectAlias } from "../../structures/ObjectAlias"; -export const test_notation_validateKebab_ObjectAlias = (): void => +export const test_notation_createValidateKebab_ObjectAlias = (): void => _test_notation_validateGeneral("ObjectAlias")(ObjectAlias)< typia.KebabCase >({ - convert: (input) => typia.notations.validateKebab(input), + convert: typia.notations.createValidateKebab(), assert: typia.createAssert>(), - }); \ No newline at end of file + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDate.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDate.ts new file mode 100644 index 00000000000..eba173072c5 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDate.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectDate } from "../../structures/ObjectDate"; + +export const test_notation_createValidateKebab_ObjectDate = (): void => + _test_notation_validateGeneral("ObjectDate")(ObjectDate)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDescription.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDescription.ts new file mode 100644 index 00000000000..bea1f71de45 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDescription.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectDescription } from "../../structures/ObjectDescription"; + +export const test_notation_createValidateKebab_ObjectDescription = (): void => + _test_notation_validateGeneral("ObjectDescription")( + ObjectDescription, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDynamic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDynamic.ts new file mode 100644 index 00000000000..5c67f65f466 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDynamic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectDynamic } from "../../structures/ObjectDynamic"; + +export const test_notation_createValidateKebab_ObjectDynamic = (): void => + _test_notation_validateGeneral("ObjectDynamic")(ObjectDynamic)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGeneric.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGeneric.ts new file mode 100644 index 00000000000..40f27def331 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGeneric.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGeneric } from "../../structures/ObjectGeneric"; + +export const test_notation_createValidateKebab_ObjectGeneric = (): void => + _test_notation_validateGeneral("ObjectGeneric")(ObjectGeneric)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericAlias.ts new file mode 100644 index 00000000000..aee6f832ce5 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGenericAlias } from "../../structures/ObjectGenericAlias"; + +export const test_notation_createValidateKebab_ObjectGenericAlias = (): void => + _test_notation_validateGeneral("ObjectGenericAlias")( + ObjectGenericAlias, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericArray.ts new file mode 100644 index 00000000000..9732f250fef --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGenericArray } from "../../structures/ObjectGenericArray"; + +export const test_notation_createValidateKebab_ObjectGenericArray = (): void => + _test_notation_validateGeneral("ObjectGenericArray")( + ObjectGenericArray, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericUnion.ts new file mode 100644 index 00000000000..e401ea9b3e6 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGenericUnion } from "../../structures/ObjectGenericUnion"; + +export const test_notation_createValidateKebab_ObjectGenericUnion = (): void => + _test_notation_validateGeneral("ObjectGenericUnion")( + ObjectGenericUnion, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHierarchical.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHierarchical.ts new file mode 100644 index 00000000000..8588745ced7 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHierarchical.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHierarchical } from "../../structures/ObjectHierarchical"; + +export const test_notation_createValidateKebab_ObjectHierarchical = (): void => + _test_notation_validateGeneral("ObjectHierarchical")( + ObjectHierarchical, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpArray.ts new file mode 100644 index 00000000000..41b43fd7a67 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpArray } from "../../structures/ObjectHttpArray"; + +export const test_notation_createValidateKebab_ObjectHttpArray = (): void => + _test_notation_validateGeneral("ObjectHttpArray")( + ObjectHttpArray, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpAtomic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpAtomic.ts new file mode 100644 index 00000000000..a2ed85acbc3 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpAtomic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpAtomic } from "../../structures/ObjectHttpAtomic"; + +export const test_notation_createValidateKebab_ObjectHttpAtomic = (): void => + _test_notation_validateGeneral("ObjectHttpAtomic")( + ObjectHttpAtomic, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpCommentTag.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpCommentTag.ts new file mode 100644 index 00000000000..4a8c7d1cf88 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpCommentTag.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpCommentTag } from "../../structures/ObjectHttpCommentTag"; + +export const test_notation_createValidateKebab_ObjectHttpCommentTag = + (): void => + _test_notation_validateGeneral( + "ObjectHttpCommentTag", + )(ObjectHttpCommentTag)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpConstant.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpConstant.ts new file mode 100644 index 00000000000..6a55d7c4090 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpConstant.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpConstant } from "../../structures/ObjectHttpConstant"; + +export const test_notation_createValidateKebab_ObjectHttpConstant = (): void => + _test_notation_validateGeneral("ObjectHttpConstant")( + ObjectHttpConstant, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpFormData.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpFormData.ts new file mode 100644 index 00000000000..2cfb239964a --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpFormData.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpFormData } from "../../structures/ObjectHttpFormData"; + +export const test_notation_createValidateKebab_ObjectHttpFormData = (): void => + _test_notation_validateGeneral("ObjectHttpFormData")( + ObjectHttpFormData, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpNullable.ts new file mode 100644 index 00000000000..c26ba57c64f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpNullable.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpNullable } from "../../structures/ObjectHttpNullable"; + +export const test_notation_createValidateKebab_ObjectHttpNullable = (): void => + _test_notation_validateGeneral("ObjectHttpNullable")( + ObjectHttpNullable, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpTypeTag.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpTypeTag.ts new file mode 100644 index 00000000000..e28c48cf2dc --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpTypeTag.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpTypeTag } from "../../structures/ObjectHttpTypeTag"; + +export const test_notation_createValidateKebab_ObjectHttpTypeTag = (): void => + _test_notation_validateGeneral("ObjectHttpTypeTag")( + ObjectHttpTypeTag, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpUndefindable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpUndefindable.ts new file mode 100644 index 00000000000..e6686abdca2 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpUndefindable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpUndefindable } from "../../structures/ObjectHttpUndefindable"; + +export const test_notation_createValidateKebab_ObjectHttpUndefindable = + (): void => + _test_notation_validateGeneral( + "ObjectHttpUndefindable", + )(ObjectHttpUndefindable)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectIntersection.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectIntersection.ts new file mode 100644 index 00000000000..dbf0ea027eb --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectIntersection.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectIntersection } from "../../structures/ObjectIntersection"; + +export const test_notation_createValidateKebab_ObjectIntersection = (): void => + _test_notation_validateGeneral("ObjectIntersection")( + ObjectIntersection, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectJsonTag.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectJsonTag.ts new file mode 100644 index 00000000000..38983b3324c --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectJsonTag.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectJsonTag } from "../../structures/ObjectJsonTag"; + +export const test_notation_createValidateKebab_ObjectJsonTag = (): void => + _test_notation_validateGeneral("ObjectJsonTag")(ObjectJsonTag)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralProperty.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralProperty.ts new file mode 100644 index 00000000000..687326511e4 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralProperty.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectLiteralProperty } from "../../structures/ObjectLiteralProperty"; + +export const test_notation_createValidateKebab_ObjectLiteralProperty = + (): void => + _test_notation_validateGeneral( + "ObjectLiteralProperty", + )(ObjectLiteralProperty)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralType.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralType.ts new file mode 100644 index 00000000000..4a1c4b0fedb --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralType.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectLiteralType } from "../../structures/ObjectLiteralType"; + +export const test_notation_createValidateKebab_ObjectLiteralType = (): void => + _test_notation_validateGeneral("ObjectLiteralType")( + ObjectLiteralType, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectNullable.ts new file mode 100644 index 00000000000..dde19e5cf67 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectNullable.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectNullable } from "../../structures/ObjectNullable"; + +export const test_notation_createValidateKebab_ObjectNullable = (): void => + _test_notation_validateGeneral("ObjectNullable")( + ObjectNullable, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectOptional.ts new file mode 100644 index 00000000000..9597f7c7988 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectOptional.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectOptional } from "../../structures/ObjectOptional"; + +export const test_notation_createValidateKebab_ObjectOptional = (): void => + _test_notation_validateGeneral("ObjectOptional")( + ObjectOptional, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartial.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartial.ts new file mode 100644 index 00000000000..c494f683a77 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartial.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPartial } from "../../structures/ObjectPartial"; + +export const test_notation_createValidateKebab_ObjectPartial = (): void => + _test_notation_validateGeneral("ObjectPartial")(ObjectPartial)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartialAndRequired.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartialAndRequired.ts new file mode 100644 index 00000000000..6349355c93b --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartialAndRequired.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPartialAndRequired } from "../../structures/ObjectPartialAndRequired"; + +export const test_notation_createValidateKebab_ObjectPartialAndRequired = + (): void => + _test_notation_validateGeneral( + "ObjectPartialAndRequired", + )(ObjectPartialAndRequired)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPrimitive.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPrimitive.ts new file mode 100644 index 00000000000..d9fe8a49ce2 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPrimitive.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPrimitive } from "../../structures/ObjectPrimitive"; + +export const test_notation_createValidateKebab_ObjectPrimitive = (): void => + _test_notation_validateGeneral("ObjectPrimitive")( + ObjectPrimitive, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPropertyNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPropertyNullable.ts new file mode 100644 index 00000000000..5747774cd02 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPropertyNullable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPropertyNullable } from "../../structures/ObjectPropertyNullable"; + +export const test_notation_createValidateKebab_ObjectPropertyNullable = + (): void => + _test_notation_validateGeneral( + "ObjectPropertyNullable", + )(ObjectPropertyNullable)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRecursive.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRecursive.ts new file mode 100644 index 00000000000..420b51b35cb --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRecursive.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectRecursive } from "../../structures/ObjectRecursive"; + +export const test_notation_createValidateKebab_ObjectRecursive = (): void => + _test_notation_validateGeneral("ObjectRecursive")( + ObjectRecursive, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRequired.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRequired.ts new file mode 100644 index 00000000000..fa8c68f2bc9 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRequired.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectRequired } from "../../structures/ObjectRequired"; + +export const test_notation_createValidateKebab_ObjectRequired = (): void => + _test_notation_validateGeneral("ObjectRequired")( + ObjectRequired, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSequenceProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSequenceProtobuf.ts new file mode 100644 index 00000000000..3c710de3d29 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSequenceProtobuf.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSequenceProtobuf } from "../../structures/ObjectSequenceProtobuf"; + +export const test_notation_createValidateKebab_ObjectSequenceProtobuf = + (): void => + _test_notation_validateGeneral( + "ObjectSequenceProtobuf", + )(ObjectSequenceProtobuf)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimple.ts new file mode 100644 index 00000000000..70a46c13964 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSimple } from "../../structures/ObjectSimple"; + +export const test_notation_createValidateKebab_ObjectSimple = (): void => + _test_notation_validateGeneral("ObjectSimple")(ObjectSimple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobuf.ts new file mode 100644 index 00000000000..1cd50dd6c4c --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobuf.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSimpleProtobuf } from "../../structures/ObjectSimpleProtobuf"; + +export const test_notation_createValidateKebab_ObjectSimpleProtobuf = + (): void => + _test_notation_validateGeneral( + "ObjectSimpleProtobuf", + )(ObjectSimpleProtobuf)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufNullable.ts new file mode 100644 index 00000000000..bc05434ae82 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufNullable.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSimpleProtobufNullable } from "../../structures/ObjectSimpleProtobufNullable"; + +export const test_notation_createValidateKebab_ObjectSimpleProtobufNullable = + (): void => + _test_notation_validateGeneral( + "ObjectSimpleProtobufNullable", + )(ObjectSimpleProtobufNullable)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufOptional.ts new file mode 100644 index 00000000000..37a01ec78c5 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufOptional.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSimpleProtobufOptional } from "../../structures/ObjectSimpleProtobufOptional"; + +export const test_notation_createValidateKebab_ObjectSimpleProtobufOptional = + (): void => + _test_notation_validateGeneral( + "ObjectSimpleProtobufOptional", + )(ObjectSimpleProtobufOptional)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectTuple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectTuple.ts new file mode 100644 index 00000000000..9a2d54f41be --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectTuple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectTuple } from "../../structures/ObjectTuple"; + +export const test_notation_createValidateKebab_ObjectTuple = (): void => + _test_notation_validateGeneral("ObjectTuple")(ObjectTuple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUndefined.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUndefined.ts new file mode 100644 index 00000000000..438370af45d --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUndefined.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUndefined } from "../../structures/ObjectUndefined"; + +export const test_notation_createValidateKebab_ObjectUndefined = (): void => + _test_notation_validateGeneral("ObjectUndefined")( + ObjectUndefined, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionComposite.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionComposite.ts new file mode 100644 index 00000000000..80528e711f1 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionComposite.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionComposite } from "../../structures/ObjectUnionComposite"; + +export const test_notation_createValidateKebab_ObjectUnionComposite = + (): void => + _test_notation_validateGeneral( + "ObjectUnionComposite", + )(ObjectUnionComposite)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionCompositePointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionCompositePointer.ts new file mode 100644 index 00000000000..f744fee1d48 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionCompositePointer.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionCompositePointer } from "../../structures/ObjectUnionCompositePointer"; + +export const test_notation_createValidateKebab_ObjectUnionCompositePointer = + (): void => + _test_notation_validateGeneral( + "ObjectUnionCompositePointer", + )(ObjectUnionCompositePointer)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionDouble.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionDouble.ts new file mode 100644 index 00000000000..3dd187f1a8e --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionDouble.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionDouble } from "../../structures/ObjectUnionDouble"; + +export const test_notation_createValidateKebab_ObjectUnionDouble = (): void => + _test_notation_validateGeneral("ObjectUnionDouble")( + ObjectUnionDouble, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicit.ts new file mode 100644 index 00000000000..71b84ffffd4 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicit.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionExplicit } from "../../structures/ObjectUnionExplicit"; + +export const test_notation_createValidateKebab_ObjectUnionExplicit = (): void => + _test_notation_validateGeneral("ObjectUnionExplicit")( + ObjectUnionExplicit, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicitPointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicitPointer.ts new file mode 100644 index 00000000000..499bf4fda20 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicitPointer.ts @@ -0,0 +1,16 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionExplicitPointer } from "../../structures/ObjectUnionExplicitPointer"; + +export const test_notation_createValidateKebab_ObjectUnionExplicitPointer = + (): void => + _test_notation_validateGeneral( + "ObjectUnionExplicitPointer", + )(ObjectUnionExplicitPointer)< + typia.KebabCase + >({ + convert: + typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionImplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionImplicit.ts new file mode 100644 index 00000000000..2e7128336b0 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionImplicit.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionImplicit } from "../../structures/ObjectUnionImplicit"; + +export const test_notation_createValidateKebab_ObjectUnionImplicit = (): void => + _test_notation_validateGeneral("ObjectUnionImplicit")( + ObjectUnionImplicit, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionNonPredictable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionNonPredictable.ts new file mode 100644 index 00000000000..926299b198d --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionNonPredictable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionNonPredictable } from "../../structures/ObjectUnionNonPredictable"; + +export const test_notation_createValidateKebab_ObjectUnionNonPredictable = + (): void => + _test_notation_validateGeneral( + "ObjectUnionNonPredictable", + )(ObjectUnionNonPredictable)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_SetAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_SetAlias.ts new file mode 100644 index 00000000000..46050581b23 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_SetAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { SetAlias } from "../../structures/SetAlias"; + +export const test_notation_createValidateKebab_SetAlias = (): void => + _test_notation_validateGeneral("SetAlias")(SetAlias)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_SetSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_SetSimple.ts new file mode 100644 index 00000000000..e296c0d7f29 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_SetSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { SetSimple } from "../../structures/SetSimple"; + +export const test_notation_createValidateKebab_SetSimple = (): void => + _test_notation_validateGeneral("SetSimple")(SetSimple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_SetUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_SetUnion.ts new file mode 100644 index 00000000000..258592eafbd --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_SetUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { SetUnion } from "../../structures/SetUnion"; + +export const test_notation_createValidateKebab_SetUnion = (): void => + _test_notation_validateGeneral("SetUnion")(SetUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TemplateAtomic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateAtomic.ts new file mode 100644 index 00000000000..d32a01d92a3 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateAtomic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TemplateAtomic } from "../../structures/TemplateAtomic"; + +export const test_notation_createValidateKebab_TemplateAtomic = (): void => + _test_notation_validateGeneral("TemplateAtomic")( + TemplateAtomic, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TemplateConstant.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateConstant.ts new file mode 100644 index 00000000000..13c8735e0c8 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateConstant.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TemplateConstant } from "../../structures/TemplateConstant"; + +export const test_notation_createValidateKebab_TemplateConstant = (): void => + _test_notation_validateGeneral("TemplateConstant")( + TemplateConstant, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TemplateUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateUnion.ts new file mode 100644 index 00000000000..8f9160e8b8a --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TemplateUnion } from "../../structures/TemplateUnion"; + +export const test_notation_createValidateKebab_TemplateUnion = (): void => + _test_notation_validateGeneral("TemplateUnion")(TemplateUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleHierarchical.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleHierarchical.ts new file mode 100644 index 00000000000..a5a41a9302f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleHierarchical.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleHierarchical } from "../../structures/TupleHierarchical"; + +export const test_notation_createValidateKebab_TupleHierarchical = (): void => + _test_notation_validateGeneral("TupleHierarchical")( + TupleHierarchical, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleOptional.ts new file mode 100644 index 00000000000..6b308beaa0e --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleOptional.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleOptional } from "../../structures/TupleOptional"; + +export const test_notation_createValidateKebab_TupleOptional = (): void => + _test_notation_validateGeneral("TupleOptional")(TupleOptional)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestArray.ts new file mode 100644 index 00000000000..3a602211f4a --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleRestArray } from "../../structures/TupleRestArray"; + +export const test_notation_createValidateKebab_TupleRestArray = (): void => + _test_notation_validateGeneral("TupleRestArray")( + TupleRestArray, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestAtomic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestAtomic.ts new file mode 100644 index 00000000000..6661da70fe4 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestAtomic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleRestAtomic } from "../../structures/TupleRestAtomic"; + +export const test_notation_createValidateKebab_TupleRestAtomic = (): void => + _test_notation_validateGeneral("TupleRestAtomic")( + TupleRestAtomic, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestObject.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestObject.ts new file mode 100644 index 00000000000..8f20b55a3f0 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestObject.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleRestObject } from "../../structures/TupleRestObject"; + +export const test_notation_createValidateKebab_TupleRestObject = (): void => + _test_notation_validateGeneral("TupleRestObject")( + TupleRestObject, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleUnion.ts new file mode 100644 index 00000000000..f5ec1839c0d --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleUnion } from "../../structures/TupleUnion"; + +export const test_notation_createValidateKebab_TupleUnion = (): void => + _test_notation_validateGeneral("TupleUnion")(TupleUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArray.ts new file mode 100644 index 00000000000..fe1ef7c08f4 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagArray } from "../../structures/TypeTagArray"; + +export const test_notation_createValidateKebab_TypeTagArray = (): void => + _test_notation_validateGeneral("TypeTagArray")(TypeTagArray)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArrayUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArrayUnion.ts new file mode 100644 index 00000000000..17dc29f565e --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArrayUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagArrayUnion } from "../../structures/TypeTagArrayUnion"; + +export const test_notation_createValidateKebab_TypeTagArrayUnion = (): void => + _test_notation_validateGeneral("TypeTagArrayUnion")( + TypeTagArrayUnion, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagAtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagAtomicUnion.ts new file mode 100644 index 00000000000..2e255d59549 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagAtomicUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagAtomicUnion } from "../../structures/TypeTagAtomicUnion"; + +export const test_notation_createValidateKebab_TypeTagAtomicUnion = (): void => + _test_notation_validateGeneral("TypeTagAtomicUnion")( + TypeTagAtomicUnion, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagBigInt.ts new file mode 100644 index 00000000000..ad86f1fcc12 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagBigInt.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagBigInt } from "../../structures/TypeTagBigInt"; + +export const test_notation_createValidateKebab_TypeTagBigInt = (): void => + _test_notation_validateGeneral("TypeTagBigInt")(TypeTagBigInt)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagCustom.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagCustom.ts new file mode 100644 index 00000000000..b51c23ea113 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagCustom.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagCustom } from "../../structures/TypeTagCustom"; + +export const test_notation_createValidateKebab_TypeTagCustom = (): void => + _test_notation_validateGeneral("TypeTagCustom")(TypeTagCustom)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagDefault.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagDefault.ts new file mode 100644 index 00000000000..966dfc1ce82 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagDefault.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagDefault } from "../../structures/TypeTagDefault"; + +export const test_notation_createValidateKebab_TypeTagDefault = (): void => + _test_notation_validateGeneral("TypeTagDefault")( + TypeTagDefault, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagFormat.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagFormat.ts new file mode 100644 index 00000000000..75bfc9097b1 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagFormat.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagFormat } from "../../structures/TypeTagFormat"; + +export const test_notation_createValidateKebab_TypeTagFormat = (): void => + _test_notation_validateGeneral("TypeTagFormat")(TypeTagFormat)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagInfinite.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagInfinite.ts new file mode 100644 index 00000000000..0d03fc494ca --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagInfinite.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagInfinite } from "../../structures/TypeTagInfinite"; + +export const test_notation_createValidateKebab_TypeTagInfinite = (): void => + _test_notation_validateGeneral("TypeTagInfinite")( + TypeTagInfinite, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagLength.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagLength.ts new file mode 100644 index 00000000000..2b11854d9be --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagLength.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagLength } from "../../structures/TypeTagLength"; + +export const test_notation_createValidateKebab_TypeTagLength = (): void => + _test_notation_validateGeneral("TypeTagLength")(TypeTagLength)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagMatrix.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagMatrix.ts new file mode 100644 index 00000000000..0d43458c6d5 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagMatrix.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagMatrix } from "../../structures/TypeTagMatrix"; + +export const test_notation_createValidateKebab_TypeTagMatrix = (): void => + _test_notation_validateGeneral("TypeTagMatrix")(TypeTagMatrix)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagNaN.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagNaN.ts new file mode 100644 index 00000000000..40d951dc8ec --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagNaN.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagNaN } from "../../structures/TypeTagNaN"; + +export const test_notation_createValidateKebab_TypeTagNaN = (): void => + _test_notation_validateGeneral("TypeTagNaN")(TypeTagNaN)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagObjectUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagObjectUnion.ts new file mode 100644 index 00000000000..fcf2cf4eb26 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagObjectUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagObjectUnion } from "../../structures/TypeTagObjectUnion"; + +export const test_notation_createValidateKebab_TypeTagObjectUnion = (): void => + _test_notation_validateGeneral("TypeTagObjectUnion")( + TypeTagObjectUnion, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagPattern.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagPattern.ts new file mode 100644 index 00000000000..81cfdbdf0c9 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagPattern.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagPattern } from "../../structures/TypeTagPattern"; + +export const test_notation_createValidateKebab_TypeTagPattern = (): void => + _test_notation_validateGeneral("TypeTagPattern")( + TypeTagPattern, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRange.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRange.ts new file mode 100644 index 00000000000..bbb57a7ba39 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRange.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagRange } from "../../structures/TypeTagRange"; + +export const test_notation_createValidateKebab_TypeTagRange = (): void => + _test_notation_validateGeneral("TypeTagRange")(TypeTagRange)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRangeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRangeBigInt.ts new file mode 100644 index 00000000000..70c9b9d0155 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRangeBigInt.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagRangeBigInt } from "../../structures/TypeTagRangeBigInt"; + +export const test_notation_createValidateKebab_TypeTagRangeBigInt = (): void => + _test_notation_validateGeneral("TypeTagRangeBigInt")( + TypeTagRangeBigInt, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTuple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTuple.ts new file mode 100644 index 00000000000..a1f79d17a8f --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTuple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagTuple } from "../../structures/TypeTagTuple"; + +export const test_notation_createValidateKebab_TypeTagTuple = (): void => + _test_notation_validateGeneral("TypeTagTuple")(TypeTagTuple)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagType.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagType.ts new file mode 100644 index 00000000000..df99fa97136 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagType.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagType } from "../../structures/TypeTagType"; + +export const test_notation_createValidateKebab_TypeTagType = (): void => + _test_notation_validateGeneral("TypeTagType")(TypeTagType)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeBigInt.ts new file mode 100644 index 00000000000..4a3764bba9c --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeBigInt.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagTypeBigInt } from "../../structures/TypeTagTypeBigInt"; + +export const test_notation_createValidateKebab_TypeTagTypeBigInt = (): void => + _test_notation_validateGeneral("TypeTagTypeBigInt")( + TypeTagTypeBigInt, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeUnion.ts new file mode 100644 index 00000000000..caac788d3a1 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagTypeUnion } from "../../structures/TypeTagTypeUnion"; + +export const test_notation_createValidateKebab_TypeTagTypeUnion = (): void => + _test_notation_validateGeneral("TypeTagTypeUnion")( + TypeTagTypeUnion, + )>({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_UltimateUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_UltimateUnion.ts new file mode 100644 index 00000000000..2dc6f792485 --- /dev/null +++ b/test/src/features/notation.createKebab/test_notation_createKebab_UltimateUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { UltimateUnion } from "../../structures/UltimateUnion"; + +export const test_notation_createValidateKebab_UltimateUnion = (): void => + _test_notation_validateGeneral("UltimateUnion")(UltimateUnion)< + typia.KebabCase + >({ + convert: typia.notations.createValidateKebab(), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts b/test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts deleted file mode 100644 index 0a7e01aae85..00000000000 --- a/test/src/features/notation.kebab/test_notation_assertKebab_ObjectSimple.ts +++ /dev/null @@ -1,12 +0,0 @@ -import typia from "typia"; - -import { _test_notation_assertGeneral } from "../../internal/_test_notation_assertGeneral"; -import { ObjectSimple } from "../../structures/ObjectSimple"; - -export const test_notation_assertKebab_ObjectSimple = (): void => - _test_notation_assertGeneral("ObjectSimple")(ObjectSimple)< - typia.KebabCase - >({ - convert: (input) => typia.notations.assertKebab(input), - assert: typia.createAssert>(), - }); \ No newline at end of file diff --git a/test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts b/test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts deleted file mode 100644 index 2f33923a785..00000000000 --- a/test/src/features/notation.kebab/test_notation_isKebab_ObjectSimple.ts +++ /dev/null @@ -1,12 +0,0 @@ -import typia from "typia"; - -import { _test_notation_isGeneral } from "../../internal/_test_notation_isGeneral"; -import { ObjectSimple } from "../../structures/ObjectSimple"; - -export const test_notation_isKebab_ObjectSimple = (): void => - _test_notation_isGeneral("ObjectSimple")(ObjectSimple)< - typia.KebabCase - >({ - convert: (input) => typia.notations.isKebab(input), - assert: typia.createAssert>(), - }); \ No newline at end of file diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayAny.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayAny.ts new file mode 100644 index 00000000000..178102908e1 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayAny.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayAny } from "../../structures/ArrayAny"; + +export const test_notation_validateKebab_ArrayAny = (): void => + _test_notation_validateGeneral("ArrayAny")(ArrayAny)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicAlias.ts new file mode 100644 index 00000000000..34e530fe53f --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayAtomicAlias } from "../../structures/ArrayAtomicAlias"; + +export const test_notation_validateKebab_ArrayAtomicAlias = (): void => + _test_notation_validateGeneral("ArrayAtomicAlias")( + ArrayAtomicAlias, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicSimple.ts new file mode 100644 index 00000000000..1bbdad06b12 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayAtomicSimple } from "../../structures/ArrayAtomicSimple"; + +export const test_notation_validateKebab_ArrayAtomicSimple = (): void => + _test_notation_validateGeneral("ArrayAtomicSimple")( + ArrayAtomicSimple, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchical.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchical.ts new file mode 100644 index 00000000000..9dbeceb4574 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchical.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayHierarchical } from "../../structures/ArrayHierarchical"; + +export const test_notation_validateKebab_ArrayHierarchical = (): void => + _test_notation_validateGeneral("ArrayHierarchical")( + ArrayHierarchical, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchicalPointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchicalPointer.ts new file mode 100644 index 00000000000..a94b34ec470 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchicalPointer.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayHierarchicalPointer } from "../../structures/ArrayHierarchicalPointer"; + +export const test_notation_validateKebab_ArrayHierarchicalPointer = (): void => + _test_notation_validateGeneral( + "ArrayHierarchicalPointer", + )(ArrayHierarchicalPointer)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayMatrix.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayMatrix.ts new file mode 100644 index 00000000000..2d82964cc75 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayMatrix.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayMatrix } from "../../structures/ArrayMatrix"; + +export const test_notation_validateKebab_ArrayMatrix = (): void => + _test_notation_validateGeneral("ArrayMatrix")(ArrayMatrix)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursive.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursive.ts new file mode 100644 index 00000000000..815720fbf1c --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursive.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursive } from "../../structures/ArrayRecursive"; + +export const test_notation_validateKebab_ArrayRecursive = (): void => + _test_notation_validateGeneral("ArrayRecursive")( + ArrayRecursive, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicit.ts new file mode 100644 index 00000000000..3ec3611cfb5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicit.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursiveUnionExplicit } from "../../structures/ArrayRecursiveUnionExplicit"; + +export const test_notation_validateKebab_ArrayRecursiveUnionExplicit = + (): void => + _test_notation_validateGeneral( + "ArrayRecursiveUnionExplicit", + )(ArrayRecursiveUnionExplicit)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicitPointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicitPointer.ts new file mode 100644 index 00000000000..a96e68f7e92 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicitPointer.ts @@ -0,0 +1,21 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursiveUnionExplicitPointer } from "../../structures/ArrayRecursiveUnionExplicitPointer"; + +export const test_notation_validateKebab_ArrayRecursiveUnionExplicitPointer = + (): void => + _test_notation_validateGeneral( + "ArrayRecursiveUnionExplicitPointer", + )(ArrayRecursiveUnionExplicitPointer)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab( + input, + ), + assert: + typia.createAssert< + typia.KebabCase + >(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionImplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionImplicit.ts new file mode 100644 index 00000000000..17f43d5fc94 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionImplicit.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRecursiveUnionImplicit } from "../../structures/ArrayRecursiveUnionImplicit"; + +export const test_notation_validateKebab_ArrayRecursiveUnionImplicit = + (): void => + _test_notation_validateGeneral( + "ArrayRecursiveUnionImplicit", + )(ArrayRecursiveUnionImplicit)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedNullable.ts new file mode 100644 index 00000000000..d8a1d7326e3 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedNullable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedNullable } from "../../structures/ArrayRepeatedNullable"; + +export const test_notation_validateKebab_ArrayRepeatedNullable = (): void => + _test_notation_validateGeneral( + "ArrayRepeatedNullable", + )(ArrayRepeatedNullable)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedOptional.ts new file mode 100644 index 00000000000..dc9a0280317 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedOptional.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedOptional } from "../../structures/ArrayRepeatedOptional"; + +export const test_notation_validateKebab_ArrayRepeatedOptional = (): void => + _test_notation_validateGeneral( + "ArrayRepeatedOptional", + )(ArrayRepeatedOptional)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedRequired.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedRequired.ts new file mode 100644 index 00000000000..954580345b7 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedRequired.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedRequired } from "../../structures/ArrayRepeatedRequired"; + +export const test_notation_validateKebab_ArrayRepeatedRequired = (): void => + _test_notation_validateGeneral( + "ArrayRepeatedRequired", + )(ArrayRepeatedRequired)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnion.ts new file mode 100644 index 00000000000..a9b46030221 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnion.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedUnion } from "../../structures/ArrayRepeatedUnion"; + +export const test_notation_validateKebab_ArrayRepeatedUnion = (): void => + _test_notation_validateGeneral("ArrayRepeatedUnion")( + ArrayRepeatedUnion, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnionWithTuple.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnionWithTuple.ts new file mode 100644 index 00000000000..05f08580625 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnionWithTuple.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayRepeatedUnionWithTuple } from "../../structures/ArrayRepeatedUnionWithTuple"; + +export const test_notation_validateKebab_ArrayRepeatedUnionWithTuple = + (): void => + _test_notation_validateGeneral( + "ArrayRepeatedUnionWithTuple", + )(ArrayRepeatedUnionWithTuple)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimple.ts new file mode 100644 index 00000000000..28883a022dc --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimple } from "../../structures/ArraySimple"; + +export const test_notation_validateKebab_ArraySimple = (): void => + _test_notation_validateGeneral("ArraySimple")(ArraySimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobuf.ts new file mode 100644 index 00000000000..369810e2648 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobuf.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimpleProtobuf } from "../../structures/ArraySimpleProtobuf"; + +export const test_notation_validateKebab_ArraySimpleProtobuf = (): void => + _test_notation_validateGeneral("ArraySimpleProtobuf")( + ArraySimpleProtobuf, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufNullable.ts new file mode 100644 index 00000000000..e7785ff428b --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufNullable.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimpleProtobufNullable } from "../../structures/ArraySimpleProtobufNullable"; + +export const test_notation_validateKebab_ArraySimpleProtobufNullable = + (): void => + _test_notation_validateGeneral( + "ArraySimpleProtobufNullable", + )(ArraySimpleProtobufNullable)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufOptional.ts new file mode 100644 index 00000000000..78c1726b789 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufOptional.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArraySimpleProtobufOptional } from "../../structures/ArraySimpleProtobufOptional"; + +export const test_notation_validateKebab_ArraySimpleProtobufOptional = + (): void => + _test_notation_validateGeneral( + "ArraySimpleProtobufOptional", + )(ArraySimpleProtobufOptional)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayUnion.ts new file mode 100644 index 00000000000..99e5d2792c4 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ArrayUnion } from "../../structures/ArrayUnion"; + +export const test_notation_validateKebab_ArrayUnion = (): void => + _test_notation_validateGeneral("ArrayUnion")(ArrayUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicAlias.ts new file mode 100644 index 00000000000..10f3276be9e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicAlias } from "../../structures/AtomicAlias"; + +export const test_notation_validateKebab_AtomicAlias = (): void => + _test_notation_validateGeneral("AtomicAlias")(AtomicAlias)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicClass.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicClass.ts new file mode 100644 index 00000000000..f1df403a7dc --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicClass.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicClass } from "../../structures/AtomicClass"; + +export const test_notation_validateKebab_AtomicClass = (): void => + _test_notation_validateGeneral("AtomicClass")(AtomicClass)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicIntersection.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicIntersection.ts new file mode 100644 index 00000000000..628d76e11b4 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicIntersection.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicIntersection } from "../../structures/AtomicIntersection"; + +export const test_notation_validateKebab_AtomicIntersection = (): void => + _test_notation_validateGeneral("AtomicIntersection")( + AtomicIntersection, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicSimple.ts new file mode 100644 index 00000000000..f1c73d53635 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicSimple } from "../../structures/AtomicSimple"; + +export const test_notation_validateKebab_AtomicSimple = (): void => + _test_notation_validateGeneral("AtomicSimple")(AtomicSimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicUnion.ts new file mode 100644 index 00000000000..90466d332fb --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { AtomicUnion } from "../../structures/AtomicUnion"; + +export const test_notation_validateKebab_AtomicUnion = (): void => + _test_notation_validateGeneral("AtomicUnion")(AtomicUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ClassMethod.ts b/test/src/features/notation.kebab/test_notation_kebab_ClassMethod.ts new file mode 100644 index 00000000000..822582aee69 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ClassMethod.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ClassMethod } from "../../structures/ClassMethod"; + +export const test_notation_validateKebab_ClassMethod = (): void => + _test_notation_validateGeneral("ClassMethod")(ClassMethod)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ClassNonPublic.ts b/test/src/features/notation.kebab/test_notation_kebab_ClassNonPublic.ts new file mode 100644 index 00000000000..21a6e805264 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ClassNonPublic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ClassNonPublic } from "../../structures/ClassNonPublic"; + +export const test_notation_validateKebab_ClassNonPublic = (): void => + _test_notation_validateGeneral("ClassNonPublic")( + ClassNonPublic, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ClassPropertyAssignment.ts b/test/src/features/notation.kebab/test_notation_kebab_ClassPropertyAssignment.ts new file mode 100644 index 00000000000..77a0ca48bde --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ClassPropertyAssignment.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ClassPropertyAssignment } from "../../structures/ClassPropertyAssignment"; + +export const test_notation_validateKebab_ClassPropertyAssignment = (): void => + _test_notation_validateGeneral( + "ClassPropertyAssignment", + )(ClassPropertyAssignment)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagArray.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArray.ts new file mode 100644 index 00000000000..72e267cf7b5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagArray } from "../../structures/CommentTagArray"; + +export const test_notation_validateKebab_CommentTagArray = (): void => + _test_notation_validateGeneral("CommentTagArray")( + CommentTagArray, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagArrayUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArrayUnion.ts new file mode 100644 index 00000000000..ab0ae78f821 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArrayUnion.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagArrayUnion } from "../../structures/CommentTagArrayUnion"; + +export const test_notation_validateKebab_CommentTagArrayUnion = (): void => + _test_notation_validateGeneral("CommentTagArrayUnion")( + CommentTagArrayUnion, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagAtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagAtomicUnion.ts new file mode 100644 index 00000000000..7d4450858be --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagAtomicUnion.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagAtomicUnion } from "../../structures/CommentTagAtomicUnion"; + +export const test_notation_validateKebab_CommentTagAtomicUnion = (): void => + _test_notation_validateGeneral( + "CommentTagAtomicUnion", + )(CommentTagAtomicUnion)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagBigInt.ts new file mode 100644 index 00000000000..48d4e352d46 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagBigInt.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagBigInt } from "../../structures/CommentTagBigInt"; + +export const test_notation_validateKebab_CommentTagBigInt = (): void => + _test_notation_validateGeneral("CommentTagBigInt")( + CommentTagBigInt, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagDefault.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagDefault.ts new file mode 100644 index 00000000000..019eac0eb23 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagDefault.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagDefault } from "../../structures/CommentTagDefault"; + +export const test_notation_validateKebab_CommentTagDefault = (): void => + _test_notation_validateGeneral("CommentTagDefault")( + CommentTagDefault, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagFormat.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagFormat.ts new file mode 100644 index 00000000000..10e36d9a266 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagFormat.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagFormat } from "../../structures/CommentTagFormat"; + +export const test_notation_validateKebab_CommentTagFormat = (): void => + _test_notation_validateGeneral("CommentTagFormat")( + CommentTagFormat, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagInfinite.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagInfinite.ts new file mode 100644 index 00000000000..450af73bcea --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagInfinite.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagInfinite } from "../../structures/CommentTagInfinite"; + +export const test_notation_validateKebab_CommentTagInfinite = (): void => + _test_notation_validateGeneral("CommentTagInfinite")( + CommentTagInfinite, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagLength.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagLength.ts new file mode 100644 index 00000000000..d2fcf5b46fe --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagLength.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagLength } from "../../structures/CommentTagLength"; + +export const test_notation_validateKebab_CommentTagLength = (): void => + _test_notation_validateGeneral("CommentTagLength")( + CommentTagLength, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagNaN.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagNaN.ts new file mode 100644 index 00000000000..7c44db616be --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagNaN.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagNaN } from "../../structures/CommentTagNaN"; + +export const test_notation_validateKebab_CommentTagNaN = (): void => + _test_notation_validateGeneral("CommentTagNaN")(CommentTagNaN)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagObjectUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagObjectUnion.ts new file mode 100644 index 00000000000..49b66a70520 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagObjectUnion.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagObjectUnion } from "../../structures/CommentTagObjectUnion"; + +export const test_notation_validateKebab_CommentTagObjectUnion = (): void => + _test_notation_validateGeneral( + "CommentTagObjectUnion", + )(CommentTagObjectUnion)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagPattern.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagPattern.ts new file mode 100644 index 00000000000..0d6cd6750e4 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagPattern.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagPattern } from "../../structures/CommentTagPattern"; + +export const test_notation_validateKebab_CommentTagPattern = (): void => + _test_notation_validateGeneral("CommentTagPattern")( + CommentTagPattern, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagRange.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRange.ts new file mode 100644 index 00000000000..3e98f066b57 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRange.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagRange } from "../../structures/CommentTagRange"; + +export const test_notation_validateKebab_CommentTagRange = (): void => + _test_notation_validateGeneral("CommentTagRange")( + CommentTagRange, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagRangeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRangeBigInt.ts new file mode 100644 index 00000000000..cec667bb9ae --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRangeBigInt.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagRangeBigInt } from "../../structures/CommentTagRangeBigInt"; + +export const test_notation_validateKebab_CommentTagRangeBigInt = (): void => + _test_notation_validateGeneral( + "CommentTagRangeBigInt", + )(CommentTagRangeBigInt)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagType.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagType.ts new file mode 100644 index 00000000000..e096621e2ac --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagType.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagType } from "../../structures/CommentTagType"; + +export const test_notation_validateKebab_CommentTagType = (): void => + _test_notation_validateGeneral("CommentTagType")( + CommentTagType, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagTypeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagTypeBigInt.ts new file mode 100644 index 00000000000..79dcdfed9b1 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagTypeBigInt.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { CommentTagTypeBigInt } from "../../structures/CommentTagTypeBigInt"; + +export const test_notation_validateKebab_CommentTagTypeBigInt = (): void => + _test_notation_validateGeneral("CommentTagTypeBigInt")( + CommentTagTypeBigInt, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicAbsorbed.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicAbsorbed.ts new file mode 100644 index 00000000000..431c38e612c --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicAbsorbed.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicAbsorbed } from "../../structures/ConstantAtomicAbsorbed"; + +export const test_notation_validateKebab_ConstantAtomicAbsorbed = (): void => + _test_notation_validateGeneral( + "ConstantAtomicAbsorbed", + )(ConstantAtomicAbsorbed)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicSimple.ts new file mode 100644 index 00000000000..8a24d6e123a --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicSimple.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicSimple } from "../../structures/ConstantAtomicSimple"; + +export const test_notation_validateKebab_ConstantAtomicSimple = (): void => + _test_notation_validateGeneral("ConstantAtomicSimple")( + ConstantAtomicSimple, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicTagged.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicTagged.ts new file mode 100644 index 00000000000..bb694b71b34 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicTagged.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicTagged } from "../../structures/ConstantAtomicTagged"; + +export const test_notation_validateKebab_ConstantAtomicTagged = (): void => + _test_notation_validateGeneral("ConstantAtomicTagged")( + ConstantAtomicTagged, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicUnion.ts new file mode 100644 index 00000000000..96b0405108a --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicUnion.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicUnion } from "../../structures/ConstantAtomicUnion"; + +export const test_notation_validateKebab_ConstantAtomicUnion = (): void => + _test_notation_validateGeneral("ConstantAtomicUnion")( + ConstantAtomicUnion, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicWrapper.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicWrapper.ts new file mode 100644 index 00000000000..12103a64876 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicWrapper.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantAtomicWrapper } from "../../structures/ConstantAtomicWrapper"; + +export const test_notation_validateKebab_ConstantAtomicWrapper = (): void => + _test_notation_validateGeneral( + "ConstantAtomicWrapper", + )(ConstantAtomicWrapper)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantConstEnumeration.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantConstEnumeration.ts new file mode 100644 index 00000000000..d4d84d53faa --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantConstEnumeration.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantConstEnumeration } from "../../structures/ConstantConstEnumeration"; + +export const test_notation_validateKebab_ConstantConstEnumeration = (): void => + _test_notation_validateGeneral( + "ConstantConstEnumeration", + )(ConstantConstEnumeration)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantEnumeration.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantEnumeration.ts new file mode 100644 index 00000000000..9dc3efa7b0b --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantEnumeration.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantEnumeration } from "../../structures/ConstantEnumeration"; + +export const test_notation_validateKebab_ConstantEnumeration = (): void => + _test_notation_validateGeneral("ConstantEnumeration")( + ConstantEnumeration, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantIntersection.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantIntersection.ts new file mode 100644 index 00000000000..345df50eb1b --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantIntersection.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ConstantIntersection } from "../../structures/ConstantIntersection"; + +export const test_notation_validateKebab_ConstantIntersection = (): void => + _test_notation_validateGeneral("ConstantIntersection")( + ConstantIntersection, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_InstanceUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_InstanceUnion.ts new file mode 100644 index 00000000000..dc33a21b654 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_InstanceUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { InstanceUnion } from "../../structures/InstanceUnion"; + +export const test_notation_validateKebab_InstanceUnion = (): void => + _test_notation_validateGeneral("InstanceUnion")(InstanceUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_MapAlias.ts new file mode 100644 index 00000000000..21defce26c7 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_MapAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapAlias } from "../../structures/MapAlias"; + +export const test_notation_validateKebab_MapAlias = (): void => + _test_notation_validateGeneral("MapAlias")(MapAlias)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimple.ts new file mode 100644 index 00000000000..2535759bbe7 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimple } from "../../structures/MapSimple"; + +export const test_notation_validateKebab_MapSimple = (): void => + _test_notation_validateGeneral("MapSimple")(MapSimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobuf.ts new file mode 100644 index 00000000000..13ee226e020 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobuf.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimpleProtobuf } from "../../structures/MapSimpleProtobuf"; + +export const test_notation_validateKebab_MapSimpleProtobuf = (): void => + _test_notation_validateGeneral("MapSimpleProtobuf")( + MapSimpleProtobuf, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufNullable.ts new file mode 100644 index 00000000000..2ac3bbd6028 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufNullable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimpleProtobufNullable } from "../../structures/MapSimpleProtobufNullable"; + +export const test_notation_validateKebab_MapSimpleProtobufNullable = (): void => + _test_notation_validateGeneral( + "MapSimpleProtobufNullable", + )(MapSimpleProtobufNullable)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufOptional.ts new file mode 100644 index 00000000000..e92581e7b16 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufOptional.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapSimpleProtobufOptional } from "../../structures/MapSimpleProtobufOptional"; + +export const test_notation_validateKebab_MapSimpleProtobufOptional = (): void => + _test_notation_validateGeneral( + "MapSimpleProtobufOptional", + )(MapSimpleProtobufOptional)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_MapUnion.ts new file mode 100644 index 00000000000..35be8b7fdcd --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_MapUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { MapUnion } from "../../structures/MapUnion"; + +export const test_notation_validateKebab_MapUnion = (): void => + _test_notation_validateGeneral("MapUnion")(MapUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_NativeSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_NativeSimple.ts new file mode 100644 index 00000000000..2edaf6c56d7 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_NativeSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { NativeSimple } from "../../structures/NativeSimple"; + +export const test_notation_validateKebab_NativeSimple = (): void => + _test_notation_validateGeneral("NativeSimple")(NativeSimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_NativeUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_NativeUnion.ts new file mode 100644 index 00000000000..697dc2024b6 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_NativeUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { NativeUnion } from "../../structures/NativeUnion"; + +export const test_notation_validateKebab_NativeUnion = (): void => + _test_notation_validateGeneral("NativeUnion")(NativeUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts index de00dc81983..66325ff1fef 100644 --- a/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts @@ -1,12 +1,12 @@ import typia from "typia"; -import { _test_notation_general } from "../../internal/_test_notation_general"; +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; import { ObjectAlias } from "../../structures/ObjectAlias"; -export const test_notation_kebab_ObjectAlias = (): void => - _test_notation_general("ObjectAlias")(ObjectAlias)< +export const test_notation_validateKebab_ObjectAlias = (): void => + _test_notation_validateGeneral("ObjectAlias")(ObjectAlias)< typia.KebabCase >({ - convert: (input) => typia.notations.kebab(input), + convert: (input) => typia.notations.validateKebab(input), assert: typia.createAssert>(), - }); \ No newline at end of file + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectDate.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectDate.ts new file mode 100644 index 00000000000..e07b1b22c0d --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectDate.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectDate } from "../../structures/ObjectDate"; + +export const test_notation_validateKebab_ObjectDate = (): void => + _test_notation_validateGeneral("ObjectDate")(ObjectDate)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectDescription.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectDescription.ts new file mode 100644 index 00000000000..d72169d72f5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectDescription.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectDescription } from "../../structures/ObjectDescription"; + +export const test_notation_validateKebab_ObjectDescription = (): void => + _test_notation_validateGeneral("ObjectDescription")( + ObjectDescription, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectDynamic.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectDynamic.ts new file mode 100644 index 00000000000..8719165fec5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectDynamic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectDynamic } from "../../structures/ObjectDynamic"; + +export const test_notation_validateKebab_ObjectDynamic = (): void => + _test_notation_validateGeneral("ObjectDynamic")(ObjectDynamic)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGeneric.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGeneric.ts new file mode 100644 index 00000000000..11fc7bbc5df --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGeneric.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGeneric } from "../../structures/ObjectGeneric"; + +export const test_notation_validateKebab_ObjectGeneric = (): void => + _test_notation_validateGeneral("ObjectGeneric")(ObjectGeneric)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericAlias.ts new file mode 100644 index 00000000000..b198a53b354 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericAlias.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGenericAlias } from "../../structures/ObjectGenericAlias"; + +export const test_notation_validateKebab_ObjectGenericAlias = (): void => + _test_notation_validateGeneral("ObjectGenericAlias")( + ObjectGenericAlias, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericArray.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericArray.ts new file mode 100644 index 00000000000..c060a945349 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericArray.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGenericArray } from "../../structures/ObjectGenericArray"; + +export const test_notation_validateKebab_ObjectGenericArray = (): void => + _test_notation_validateGeneral("ObjectGenericArray")( + ObjectGenericArray, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericUnion.ts new file mode 100644 index 00000000000..a07387ff486 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericUnion.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectGenericUnion } from "../../structures/ObjectGenericUnion"; + +export const test_notation_validateKebab_ObjectGenericUnion = (): void => + _test_notation_validateGeneral("ObjectGenericUnion")( + ObjectGenericUnion, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHierarchical.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHierarchical.ts new file mode 100644 index 00000000000..749a983815e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHierarchical.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHierarchical } from "../../structures/ObjectHierarchical"; + +export const test_notation_validateKebab_ObjectHierarchical = (): void => + _test_notation_validateGeneral("ObjectHierarchical")( + ObjectHierarchical, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpArray.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpArray.ts new file mode 100644 index 00000000000..50d5c607338 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpArray } from "../../structures/ObjectHttpArray"; + +export const test_notation_validateKebab_ObjectHttpArray = (): void => + _test_notation_validateGeneral("ObjectHttpArray")( + ObjectHttpArray, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpAtomic.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpAtomic.ts new file mode 100644 index 00000000000..62f16830fb3 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpAtomic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpAtomic } from "../../structures/ObjectHttpAtomic"; + +export const test_notation_validateKebab_ObjectHttpAtomic = (): void => + _test_notation_validateGeneral("ObjectHttpAtomic")( + ObjectHttpAtomic, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpCommentTag.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpCommentTag.ts new file mode 100644 index 00000000000..829d35c0484 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpCommentTag.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpCommentTag } from "../../structures/ObjectHttpCommentTag"; + +export const test_notation_validateKebab_ObjectHttpCommentTag = (): void => + _test_notation_validateGeneral("ObjectHttpCommentTag")( + ObjectHttpCommentTag, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpConstant.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpConstant.ts new file mode 100644 index 00000000000..8365bcb236e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpConstant.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpConstant } from "../../structures/ObjectHttpConstant"; + +export const test_notation_validateKebab_ObjectHttpConstant = (): void => + _test_notation_validateGeneral("ObjectHttpConstant")( + ObjectHttpConstant, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpFormData.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpFormData.ts new file mode 100644 index 00000000000..7ee2bbbdaff --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpFormData.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpFormData } from "../../structures/ObjectHttpFormData"; + +export const test_notation_validateKebab_ObjectHttpFormData = (): void => + _test_notation_validateGeneral("ObjectHttpFormData")( + ObjectHttpFormData, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpNullable.ts new file mode 100644 index 00000000000..f9da0f6951e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpNullable.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpNullable } from "../../structures/ObjectHttpNullable"; + +export const test_notation_validateKebab_ObjectHttpNullable = (): void => + _test_notation_validateGeneral("ObjectHttpNullable")( + ObjectHttpNullable, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpTypeTag.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpTypeTag.ts new file mode 100644 index 00000000000..b57d03085e3 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpTypeTag.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpTypeTag } from "../../structures/ObjectHttpTypeTag"; + +export const test_notation_validateKebab_ObjectHttpTypeTag = (): void => + _test_notation_validateGeneral("ObjectHttpTypeTag")( + ObjectHttpTypeTag, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpUndefindable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpUndefindable.ts new file mode 100644 index 00000000000..7965126e5dd --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpUndefindable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectHttpUndefindable } from "../../structures/ObjectHttpUndefindable"; + +export const test_notation_validateKebab_ObjectHttpUndefindable = (): void => + _test_notation_validateGeneral( + "ObjectHttpUndefindable", + )(ObjectHttpUndefindable)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectIntersection.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectIntersection.ts new file mode 100644 index 00000000000..ebc0c68a4a4 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectIntersection.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectIntersection } from "../../structures/ObjectIntersection"; + +export const test_notation_validateKebab_ObjectIntersection = (): void => + _test_notation_validateGeneral("ObjectIntersection")( + ObjectIntersection, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectJsonTag.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectJsonTag.ts new file mode 100644 index 00000000000..49f73c549e4 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectJsonTag.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectJsonTag } from "../../structures/ObjectJsonTag"; + +export const test_notation_validateKebab_ObjectJsonTag = (): void => + _test_notation_validateGeneral("ObjectJsonTag")(ObjectJsonTag)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralProperty.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralProperty.ts new file mode 100644 index 00000000000..7bdacc7e578 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralProperty.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectLiteralProperty } from "../../structures/ObjectLiteralProperty"; + +export const test_notation_validateKebab_ObjectLiteralProperty = (): void => + _test_notation_validateGeneral( + "ObjectLiteralProperty", + )(ObjectLiteralProperty)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralType.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralType.ts new file mode 100644 index 00000000000..f5b946ee243 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralType.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectLiteralType } from "../../structures/ObjectLiteralType"; + +export const test_notation_validateKebab_ObjectLiteralType = (): void => + _test_notation_validateGeneral("ObjectLiteralType")( + ObjectLiteralType, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectNullable.ts new file mode 100644 index 00000000000..f4d57e3ddd5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectNullable.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectNullable } from "../../structures/ObjectNullable"; + +export const test_notation_validateKebab_ObjectNullable = (): void => + _test_notation_validateGeneral("ObjectNullable")( + ObjectNullable, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectOptional.ts new file mode 100644 index 00000000000..46c22a2b475 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectOptional.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectOptional } from "../../structures/ObjectOptional"; + +export const test_notation_validateKebab_ObjectOptional = (): void => + _test_notation_validateGeneral("ObjectOptional")( + ObjectOptional, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPartial.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartial.ts new file mode 100644 index 00000000000..c633c9f0999 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartial.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPartial } from "../../structures/ObjectPartial"; + +export const test_notation_validateKebab_ObjectPartial = (): void => + _test_notation_validateGeneral("ObjectPartial")(ObjectPartial)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPartialAndRequired.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartialAndRequired.ts new file mode 100644 index 00000000000..24a95202fff --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartialAndRequired.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPartialAndRequired } from "../../structures/ObjectPartialAndRequired"; + +export const test_notation_validateKebab_ObjectPartialAndRequired = (): void => + _test_notation_validateGeneral( + "ObjectPartialAndRequired", + )(ObjectPartialAndRequired)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPrimitive.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPrimitive.ts new file mode 100644 index 00000000000..4605ff0248e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPrimitive.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPrimitive } from "../../structures/ObjectPrimitive"; + +export const test_notation_validateKebab_ObjectPrimitive = (): void => + _test_notation_validateGeneral("ObjectPrimitive")( + ObjectPrimitive, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPropertyNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPropertyNullable.ts new file mode 100644 index 00000000000..79a27daecce --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPropertyNullable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectPropertyNullable } from "../../structures/ObjectPropertyNullable"; + +export const test_notation_validateKebab_ObjectPropertyNullable = (): void => + _test_notation_validateGeneral( + "ObjectPropertyNullable", + )(ObjectPropertyNullable)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectRecursive.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectRecursive.ts new file mode 100644 index 00000000000..d8d7487a06d --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectRecursive.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectRecursive } from "../../structures/ObjectRecursive"; + +export const test_notation_validateKebab_ObjectRecursive = (): void => + _test_notation_validateGeneral("ObjectRecursive")( + ObjectRecursive, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectRequired.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectRequired.ts new file mode 100644 index 00000000000..3cc04a4d060 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectRequired.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectRequired } from "../../structures/ObjectRequired"; + +export const test_notation_validateKebab_ObjectRequired = (): void => + _test_notation_validateGeneral("ObjectRequired")( + ObjectRequired, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSequenceProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSequenceProtobuf.ts new file mode 100644 index 00000000000..bd902d7b2fa --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSequenceProtobuf.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSequenceProtobuf } from "../../structures/ObjectSequenceProtobuf"; + +export const test_notation_validateKebab_ObjectSequenceProtobuf = (): void => + _test_notation_validateGeneral( + "ObjectSequenceProtobuf", + )(ObjectSequenceProtobuf)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts index 2bfd4ed1423..a4141df8061 100644 --- a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts @@ -1,12 +1,12 @@ import typia from "typia"; -import { _test_notation_general } from "../../internal/_test_notation_general"; +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; import { ObjectSimple } from "../../structures/ObjectSimple"; -export const test_notation_kebab_ObjectSimple = (): void => - _test_notation_general("ObjectSimple")(ObjectSimple)< +export const test_notation_validateKebab_ObjectSimple = (): void => + _test_notation_validateGeneral("ObjectSimple")(ObjectSimple)< typia.KebabCase >({ - convert: (input) => typia.notations.kebab(input), + convert: (input) => typia.notations.validateKebab(input), assert: typia.createAssert>(), }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobuf.ts new file mode 100644 index 00000000000..234621ada8f --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobuf.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSimpleProtobuf } from "../../structures/ObjectSimpleProtobuf"; + +export const test_notation_validateKebab_ObjectSimpleProtobuf = (): void => + _test_notation_validateGeneral("ObjectSimpleProtobuf")( + ObjectSimpleProtobuf, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufNullable.ts new file mode 100644 index 00000000000..df42a7f4ca5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufNullable.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSimpleProtobufNullable } from "../../structures/ObjectSimpleProtobufNullable"; + +export const test_notation_validateKebab_ObjectSimpleProtobufNullable = + (): void => + _test_notation_validateGeneral( + "ObjectSimpleProtobufNullable", + )(ObjectSimpleProtobufNullable)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufOptional.ts new file mode 100644 index 00000000000..07989843a58 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufOptional.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectSimpleProtobufOptional } from "../../structures/ObjectSimpleProtobufOptional"; + +export const test_notation_validateKebab_ObjectSimpleProtobufOptional = + (): void => + _test_notation_validateGeneral( + "ObjectSimpleProtobufOptional", + )(ObjectSimpleProtobufOptional)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectTuple.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectTuple.ts new file mode 100644 index 00000000000..3a27c0dc0ad --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectTuple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectTuple } from "../../structures/ObjectTuple"; + +export const test_notation_validateKebab_ObjectTuple = (): void => + _test_notation_validateGeneral("ObjectTuple")(ObjectTuple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUndefined.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUndefined.ts new file mode 100644 index 00000000000..f69df9ef02c --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUndefined.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUndefined } from "../../structures/ObjectUndefined"; + +export const test_notation_validateKebab_ObjectUndefined = (): void => + _test_notation_validateGeneral("ObjectUndefined")( + ObjectUndefined, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionComposite.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionComposite.ts new file mode 100644 index 00000000000..3b2d2dbdf2a --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionComposite.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionComposite } from "../../structures/ObjectUnionComposite"; + +export const test_notation_validateKebab_ObjectUnionComposite = (): void => + _test_notation_validateGeneral("ObjectUnionComposite")( + ObjectUnionComposite, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionCompositePointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionCompositePointer.ts new file mode 100644 index 00000000000..d6fc2ac3874 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionCompositePointer.ts @@ -0,0 +1,17 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionCompositePointer } from "../../structures/ObjectUnionCompositePointer"; + +export const test_notation_validateKebab_ObjectUnionCompositePointer = + (): void => + _test_notation_validateGeneral( + "ObjectUnionCompositePointer", + )(ObjectUnionCompositePointer)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: + typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionDouble.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionDouble.ts new file mode 100644 index 00000000000..29ab4460e1d --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionDouble.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionDouble } from "../../structures/ObjectUnionDouble"; + +export const test_notation_validateKebab_ObjectUnionDouble = (): void => + _test_notation_validateGeneral("ObjectUnionDouble")( + ObjectUnionDouble, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicit.ts new file mode 100644 index 00000000000..a3410c58035 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicit.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionExplicit } from "../../structures/ObjectUnionExplicit"; + +export const test_notation_validateKebab_ObjectUnionExplicit = (): void => + _test_notation_validateGeneral("ObjectUnionExplicit")( + ObjectUnionExplicit, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicitPointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicitPointer.ts new file mode 100644 index 00000000000..9b3f522020e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicitPointer.ts @@ -0,0 +1,16 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionExplicitPointer } from "../../structures/ObjectUnionExplicitPointer"; + +export const test_notation_validateKebab_ObjectUnionExplicitPointer = + (): void => + _test_notation_validateGeneral( + "ObjectUnionExplicitPointer", + )(ObjectUnionExplicitPointer)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionImplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionImplicit.ts new file mode 100644 index 00000000000..589dfd08016 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionImplicit.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionImplicit } from "../../structures/ObjectUnionImplicit"; + +export const test_notation_validateKebab_ObjectUnionImplicit = (): void => + _test_notation_validateGeneral("ObjectUnionImplicit")( + ObjectUnionImplicit, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionNonPredictable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionNonPredictable.ts new file mode 100644 index 00000000000..3de561ce885 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionNonPredictable.ts @@ -0,0 +1,15 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { ObjectUnionNonPredictable } from "../../structures/ObjectUnionNonPredictable"; + +export const test_notation_validateKebab_ObjectUnionNonPredictable = (): void => + _test_notation_validateGeneral( + "ObjectUnionNonPredictable", + )(ObjectUnionNonPredictable)< + typia.KebabCase + >({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_SetAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_SetAlias.ts new file mode 100644 index 00000000000..caa9aac84b5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_SetAlias.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { SetAlias } from "../../structures/SetAlias"; + +export const test_notation_validateKebab_SetAlias = (): void => + _test_notation_validateGeneral("SetAlias")(SetAlias)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_SetSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_SetSimple.ts new file mode 100644 index 00000000000..0855bb3a8e1 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_SetSimple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { SetSimple } from "../../structures/SetSimple"; + +export const test_notation_validateKebab_SetSimple = (): void => + _test_notation_validateGeneral("SetSimple")(SetSimple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_SetUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_SetUnion.ts new file mode 100644 index 00000000000..163653abd41 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_SetUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { SetUnion } from "../../structures/SetUnion"; + +export const test_notation_validateKebab_SetUnion = (): void => + _test_notation_validateGeneral("SetUnion")(SetUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TemplateAtomic.ts b/test/src/features/notation.kebab/test_notation_kebab_TemplateAtomic.ts new file mode 100644 index 00000000000..88890b8482a --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TemplateAtomic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TemplateAtomic } from "../../structures/TemplateAtomic"; + +export const test_notation_validateKebab_TemplateAtomic = (): void => + _test_notation_validateGeneral("TemplateAtomic")( + TemplateAtomic, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TemplateConstant.ts b/test/src/features/notation.kebab/test_notation_kebab_TemplateConstant.ts new file mode 100644 index 00000000000..49dc21e00cf --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TemplateConstant.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TemplateConstant } from "../../structures/TemplateConstant"; + +export const test_notation_validateKebab_TemplateConstant = (): void => + _test_notation_validateGeneral("TemplateConstant")( + TemplateConstant, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TemplateUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TemplateUnion.ts new file mode 100644 index 00000000000..1a97d918c4e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TemplateUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TemplateUnion } from "../../structures/TemplateUnion"; + +export const test_notation_validateKebab_TemplateUnion = (): void => + _test_notation_validateGeneral("TemplateUnion")(TemplateUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleHierarchical.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleHierarchical.ts new file mode 100644 index 00000000000..c70adfdc50d --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TupleHierarchical.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleHierarchical } from "../../structures/TupleHierarchical"; + +export const test_notation_validateKebab_TupleHierarchical = (): void => + _test_notation_validateGeneral("TupleHierarchical")( + TupleHierarchical, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleOptional.ts new file mode 100644 index 00000000000..f9bd1940492 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TupleOptional.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleOptional } from "../../structures/TupleOptional"; + +export const test_notation_validateKebab_TupleOptional = (): void => + _test_notation_validateGeneral("TupleOptional")(TupleOptional)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleRestArray.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleRestArray.ts new file mode 100644 index 00000000000..22dce23edc9 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TupleRestArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleRestArray } from "../../structures/TupleRestArray"; + +export const test_notation_validateKebab_TupleRestArray = (): void => + _test_notation_validateGeneral("TupleRestArray")( + TupleRestArray, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleRestAtomic.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleRestAtomic.ts new file mode 100644 index 00000000000..1c05cb5323d --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TupleRestAtomic.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleRestAtomic } from "../../structures/TupleRestAtomic"; + +export const test_notation_validateKebab_TupleRestAtomic = (): void => + _test_notation_validateGeneral("TupleRestAtomic")( + TupleRestAtomic, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleRestObject.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleRestObject.ts new file mode 100644 index 00000000000..673922463ba --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TupleRestObject.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleRestObject } from "../../structures/TupleRestObject"; + +export const test_notation_validateKebab_TupleRestObject = (): void => + _test_notation_validateGeneral("TupleRestObject")( + TupleRestObject, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleUnion.ts new file mode 100644 index 00000000000..87e3e3912a2 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TupleUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TupleUnion } from "../../structures/TupleUnion"; + +export const test_notation_validateKebab_TupleUnion = (): void => + _test_notation_validateGeneral("TupleUnion")(TupleUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagArray.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArray.ts new file mode 100644 index 00000000000..4daf112987f --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArray.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagArray } from "../../structures/TypeTagArray"; + +export const test_notation_validateKebab_TypeTagArray = (): void => + _test_notation_validateGeneral("TypeTagArray")(TypeTagArray)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagArrayUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArrayUnion.ts new file mode 100644 index 00000000000..461c4c91e64 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArrayUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagArrayUnion } from "../../structures/TypeTagArrayUnion"; + +export const test_notation_validateKebab_TypeTagArrayUnion = (): void => + _test_notation_validateGeneral("TypeTagArrayUnion")( + TypeTagArrayUnion, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagAtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagAtomicUnion.ts new file mode 100644 index 00000000000..be4cbe9e95d --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagAtomicUnion.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagAtomicUnion } from "../../structures/TypeTagAtomicUnion"; + +export const test_notation_validateKebab_TypeTagAtomicUnion = (): void => + _test_notation_validateGeneral("TypeTagAtomicUnion")( + TypeTagAtomicUnion, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagBigInt.ts new file mode 100644 index 00000000000..7db6873be0b --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagBigInt.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagBigInt } from "../../structures/TypeTagBigInt"; + +export const test_notation_validateKebab_TypeTagBigInt = (): void => + _test_notation_validateGeneral("TypeTagBigInt")(TypeTagBigInt)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagCustom.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagCustom.ts new file mode 100644 index 00000000000..8b7f2029857 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagCustom.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagCustom } from "../../structures/TypeTagCustom"; + +export const test_notation_validateKebab_TypeTagCustom = (): void => + _test_notation_validateGeneral("TypeTagCustom")(TypeTagCustom)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagDefault.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagDefault.ts new file mode 100644 index 00000000000..38958c2af92 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagDefault.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagDefault } from "../../structures/TypeTagDefault"; + +export const test_notation_validateKebab_TypeTagDefault = (): void => + _test_notation_validateGeneral("TypeTagDefault")( + TypeTagDefault, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagFormat.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagFormat.ts new file mode 100644 index 00000000000..6ef8a696256 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagFormat.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagFormat } from "../../structures/TypeTagFormat"; + +export const test_notation_validateKebab_TypeTagFormat = (): void => + _test_notation_validateGeneral("TypeTagFormat")(TypeTagFormat)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagInfinite.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagInfinite.ts new file mode 100644 index 00000000000..3b0f553f234 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagInfinite.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagInfinite } from "../../structures/TypeTagInfinite"; + +export const test_notation_validateKebab_TypeTagInfinite = (): void => + _test_notation_validateGeneral("TypeTagInfinite")( + TypeTagInfinite, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagLength.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagLength.ts new file mode 100644 index 00000000000..15357bd5f5a --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagLength.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagLength } from "../../structures/TypeTagLength"; + +export const test_notation_validateKebab_TypeTagLength = (): void => + _test_notation_validateGeneral("TypeTagLength")(TypeTagLength)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagMatrix.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagMatrix.ts new file mode 100644 index 00000000000..9f2daa0c1b4 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagMatrix.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagMatrix } from "../../structures/TypeTagMatrix"; + +export const test_notation_validateKebab_TypeTagMatrix = (): void => + _test_notation_validateGeneral("TypeTagMatrix")(TypeTagMatrix)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagNaN.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagNaN.ts new file mode 100644 index 00000000000..423cc89769f --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagNaN.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagNaN } from "../../structures/TypeTagNaN"; + +export const test_notation_validateKebab_TypeTagNaN = (): void => + _test_notation_validateGeneral("TypeTagNaN")(TypeTagNaN)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagObjectUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagObjectUnion.ts new file mode 100644 index 00000000000..c373b69651e --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagObjectUnion.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagObjectUnion } from "../../structures/TypeTagObjectUnion"; + +export const test_notation_validateKebab_TypeTagObjectUnion = (): void => + _test_notation_validateGeneral("TypeTagObjectUnion")( + TypeTagObjectUnion, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagPattern.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagPattern.ts new file mode 100644 index 00000000000..a0419dceb62 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagPattern.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagPattern } from "../../structures/TypeTagPattern"; + +export const test_notation_validateKebab_TypeTagPattern = (): void => + _test_notation_validateGeneral("TypeTagPattern")( + TypeTagPattern, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagRange.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRange.ts new file mode 100644 index 00000000000..ff77c0cc0a0 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRange.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagRange } from "../../structures/TypeTagRange"; + +export const test_notation_validateKebab_TypeTagRange = (): void => + _test_notation_validateGeneral("TypeTagRange")(TypeTagRange)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagRangeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRangeBigInt.ts new file mode 100644 index 00000000000..1ffbc47e3d9 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRangeBigInt.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagRangeBigInt } from "../../structures/TypeTagRangeBigInt"; + +export const test_notation_validateKebab_TypeTagRangeBigInt = (): void => + _test_notation_validateGeneral("TypeTagRangeBigInt")( + TypeTagRangeBigInt, + )>({ + convert: (input) => + typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagTuple.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTuple.ts new file mode 100644 index 00000000000..04d885a7f03 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTuple.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagTuple } from "../../structures/TypeTagTuple"; + +export const test_notation_validateKebab_TypeTagTuple = (): void => + _test_notation_validateGeneral("TypeTagTuple")(TypeTagTuple)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagType.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagType.ts new file mode 100644 index 00000000000..3056cb51668 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagType.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagType } from "../../structures/TypeTagType"; + +export const test_notation_validateKebab_TypeTagType = (): void => + _test_notation_validateGeneral("TypeTagType")(TypeTagType)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeBigInt.ts new file mode 100644 index 00000000000..c674963ad36 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeBigInt.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagTypeBigInt } from "../../structures/TypeTagTypeBigInt"; + +export const test_notation_validateKebab_TypeTagTypeBigInt = (): void => + _test_notation_validateGeneral("TypeTagTypeBigInt")( + TypeTagTypeBigInt, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeUnion.ts new file mode 100644 index 00000000000..f0370a68c24 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { TypeTagTypeUnion } from "../../structures/TypeTagTypeUnion"; + +export const test_notation_validateKebab_TypeTagTypeUnion = (): void => + _test_notation_validateGeneral("TypeTagTypeUnion")( + TypeTagTypeUnion, + )>({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); diff --git a/test/src/features/notation.kebab/test_notation_kebab_UltimateUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_UltimateUnion.ts new file mode 100644 index 00000000000..bdd6e8dc7d5 --- /dev/null +++ b/test/src/features/notation.kebab/test_notation_kebab_UltimateUnion.ts @@ -0,0 +1,12 @@ +import typia from "typia"; + +import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral"; +import { UltimateUnion } from "../../structures/UltimateUnion"; + +export const test_notation_validateKebab_UltimateUnion = (): void => + _test_notation_validateGeneral("UltimateUnion")(UltimateUnion)< + typia.KebabCase + >({ + convert: (input) => typia.notations.validateKebab(input), + assert: typia.createAssert>(), + }); From e777f0f91900de8f9f248ec4f50d7aca876f3061 Mon Sep 17 00:00:00 2001 From: Jeongho Nam Date: Mon, 22 Sep 2025 01:18:39 +0900 Subject: [PATCH 6/7] Try again --- src/internal/_notationKebab.ts | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 src/internal/_notationKebab.ts diff --git a/src/internal/_notationKebab.ts b/src/internal/_notationKebab.ts new file mode 100644 index 00000000000..f9c85b0701f --- /dev/null +++ b/src/internal/_notationKebab.ts @@ -0,0 +1,6 @@ +import { __notationUnsnake } from "./private/__notationUnsnake"; + +export const _notationKebab = __notationUnsnake({ + plain: str => str, + snake: (str, i) => (i === 0 ? str.toLowerCase() : `-${str.toLowerCase()}`), +}); \ No newline at end of file From ac1b1091287c846211a1061b1ecfedbfbe188957 Mon Sep 17 00:00:00 2001 From: Jeongho Nam Date: Mon, 22 Sep 2025 01:56:54 +0900 Subject: [PATCH 7/7] Fix again --- src/internal/_notationKebab.ts | 54 +++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 4 deletions(-) diff --git a/src/internal/_notationKebab.ts b/src/internal/_notationKebab.ts index f9c85b0701f..915c95db403 100644 --- a/src/internal/_notationKebab.ts +++ b/src/internal/_notationKebab.ts @@ -1,6 +1,52 @@ import { __notationUnsnake } from "./private/__notationUnsnake"; -export const _notationKebab = __notationUnsnake({ - plain: str => str, - snake: (str, i) => (i === 0 ? str.toLowerCase() : `-${str.toLowerCase()}`), -}); \ No newline at end of file +export const _notationKebab = (str: string): string => { + if (str.length === 0) return str; + + // PREFIX (handle leading hyphens and underscores) + let prefix: string = ""; + for (let i: number = 0; i < str.length; i++) { + if (str[i] === "-" || str[i] === "_") prefix += str[i]; + else break; + } + if (prefix.length !== 0) str = str.substring(prefix.length); + + const out = (s: string) => `${prefix}${s}`; + + // Handle snake_case input + if (str.includes("_")) { + const items: string[] = str.split("_"); + return out(items.map((s) => s.toLowerCase()).join("-")); + } + + // Handle kebab-case input (already kebab) + if (str.includes("-")) { + const items: string[] = str.split("-"); + return out(items.map((s) => s.toLowerCase()).join("-")); + } + + // CAMEL OR PASCAL CASE + const indexes: number[] = []; + for (let i: number = 0; i < str.length; i++) { + const code: number = str.charCodeAt(i); + if (65 <= code && code <= 90) indexes.push(i); + } + for (let i: number = indexes.length - 1; i > 0; --i) { + const now: number = indexes[i]!; + const prev: number = indexes[i - 1]!; + if (now - prev === 1) indexes.splice(i, 1); + } + if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1); + if (indexes.length === 0) return out(str.toLowerCase()); + + let ret: string = ""; + for (let i: number = 0; i < indexes.length; i++) { + const first: number = i === 0 ? 0 : indexes[i - 1]!; + const last: number = indexes[i]!; + + ret += str.substring(first, last).toLowerCase(); + ret += "-"; + } + ret += str.substring(indexes[indexes.length - 1]!).toLowerCase(); + return out(ret); +} \ No newline at end of file