feat: finish Nullable type

README.md

@@ -2,19 +2,25 @@
 Bullet proof TypeScript even more
 ### Installation 
 ```bash
+# npm 
 npm i ts-extended
+
+# pnpm
+pnpm i ts-extended
+
+# yarn 
+yarn add ts-extended
 ```
 
 ### Example
 ```ts
-import { 
-    locked,
-    final,
+import type { 
     Maybe,
     Primitive,
     Newable,
     Callable
 } from 'ts-extended';
+import { locked, final } from 'ts-extended';
 
 export type F<A extends Primitive, R extends Newable> = Callable<A[], R>;
 

src/index.ts

@@ -1,4 +1,9 @@
+/**
+ * `Nullable` type allows representing a value that can be either null or undefined.
+ * @type {Nullable}
+ */
 export type Nullable = null | undefined;
+
 export type Numeric = number | bigint;
 export type Primitive = Nullable | Numeric | string | boolean | symbol;
 export type Falsy = false | '' | 0 | Nullable;

tests/nullable.test.ts

@@ -0,0 +1,34 @@
+import { Nullable } from 'src';
+import { describe, assertType, expect, expectTypeOf, test, it } from 'vitest';
+
+test.fails('fail test', () => {
+  type _T = { foo: boolean };
+  // @ts-expect-error, it cannot be a _T, it should error out
+  expect(assertType<_T>(null)).rejects.toBe(true);
+});
+
+test('concrete types', () => {
+  expectTypeOf(null).toMatchTypeOf<Nullable>();
+  expectTypeOf(undefined).toMatchTypeOf<Nullable>();
+});
+
+describe('_', () => {
+  it('should accept null', () => {
+    const value: Nullable = null;
+    expect(value).toBeNull();
+  });
+  it('should accept undefined', () => {
+    const value: Nullable = undefined;
+    expect(value).toBeUndefined();
+  });
+
+  it('should handle type unions with Nullable', () => {
+    type _Union = string | Nullable;
+    const value1: _Union = 'foo';
+    expect(value1).toBe('foo');
+    const value2: _Union = null;
+    expect(value2).toBeNull();
+    const value3: _Union = undefined;
+    expect(value3).toBeUndefined();
+  });
+});

vitest.config.ts

@@ -1,31 +1,14 @@
 import tsconfigPaths from 'vite-tsconfig-paths';
 import { defineConfig } from 'vitest/config';
-import { MaybeUndefined } from '@/index';
-
-function _getBoolean(enVar: MaybeUndefined<string>): boolean {
-  if (enVar === undefined) {
-    return false;
-  }
-  const asNumber = Number(enVar);
-  return Number.isNaN(asNumber)
-    ? Boolean(String(enVar).toLowerCase().replace('false', ''))
-    : Boolean(asNumber);
-}
-
-const _useCompiledTests = _getBoolean(process.env['USE_COMPILED_TESTS']);
-
-const _testFilePattern = `${
-  _useCompiledTests ? './tests-compiled' : '.'
-}/**/*.test.${_useCompiledTests ? 'js' : 'ts'}`;
 
 export default defineConfig({
   plugins: [tsconfigPaths()],
   test: {
-    include: [_testFilePattern],
+    includeSource: ['src/**/[!index]*.ts'],
     coverage: {
+      reporter: ['lcov', 'text', 'json', 'html'],
       all: true,
       include: ['src/**/*'],
-      reporter: ['lcov', 'text'],
       watermarks: {
         lines: [80, 95],
         functions: [80, 95],