Make literals work with null

src/module.ts

@@ -971,7 +971,7 @@ export function literals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function literals<T extends Atomic.Type>(): T[];
+export function literals<T extends Atomic.Type | null>(): T[];
 
 /**
  * @internal

src/programmers/LiteralsProgrammer.ts

@@ -28,16 +28,18 @@ export namespace LiteralsProgrammer {
                     throw new Error(ErrorMessages.ONLY);
             },
         })(new MetadataCollection())(type);
-        const values: Set<Atomic.Type> = new Set([
+        const values: Set<Atomic.Type | null> = new Set([
             ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
             ...(meta.atomics.filter((type) => type === "boolean").length
                 ? [true, false]
                 : []),
+            ...meta.nullable ? [null] : []
         ]);
         return ts.factory.createAsExpression(
             ts.factory.createArrayLiteralExpression(
                 [...values].map((v) =>
-                    typeof v === "boolean"
+                    v === null ? ts.factory.createNull()
+                    : typeof v === "boolean"
                         ? v
                             ? ts.factory.createTrue()
                             : ts.factory.createFalse()

test/features/literals/test_literals_WithNull.ts

@@ -0,0 +1,13 @@
+import typia from '../../../src';
+import { _test_literals } from '../../internal/_test_literals';
+
+const areArraysEqual = <T>(a: T[], b: T[]): boolean => a.length === b.length && a.every((elem, i) => elem === b[i]);
+
+export const test_literals_WithNull = _test_literals(
+    'WithNull',
+    () => 'A' as 'A' | 'B' | null,
+    (input) => {
+        const generatedArray = typia.literals<typeof input>();
+        return areArraysEqual(generatedArray, ['A', 'B', null]);
+    }
+);

test/features/literals/test_literals_WithStrings.ts

@@ -0,0 +1,10 @@
+import typia from '../../../src';
+import { _test_literals } from '../../internal/_test_literals';
+
+const areArraysEqual = <T>(a: T[], b: T[]): boolean => a.length === b.length && a.every((elem, i) => elem === b[i]);
+
+export const test_literals_WithStrings = _test_literals(
+    'WithStrings',
+    () => 'A' as 'A' | 'B',
+    (input) => areArraysEqual(typia.literals<typeof input>(), ['A', 'B'])
+);

test/internal/_test_literals.ts

@@ -0,0 +1,5 @@
+export function _test_literals<T>(name: string, generator: () => T, validator: (input: T) => boolean): () => void {
+    return () => {
+        if (validator(generator()) === false) throw new Error(`Bug on typia.literals() for ${ name }: array is different than expected`);
+    };
+}