NonNullableKeys (#11)

libs/ts-standard/ex/filter.ex.ts

@@ -6,7 +6,12 @@
 
 import { isNonNullable } from "@";
 
+import { isNonNullableKeys } from "../src/filter";
 import { is } from "./shared.ex";
 
-// isNonNullable
+// `isNonNullable<T>`
 is<string[]>(["hello", "there", null, undefined].filter(isNonNullable));
+
+// `isNonNullableKeys<T>`
+is<{ hello: string; }[]>([{ hello: "there" }, { hello: null }, { hello: undefined }]
+  .filter(isNonNullableKeys(["hello"])));

libs/ts-standard/ex/type.ex.ts

@@ -4,17 +4,25 @@
  * @module
  */
 
-import { Nullable, Opt } from "@";
+import { NonNullableKeys, Nullable, Opt } from "@";
 
 import { is } from "./shared.ex";
 
-// Opt<T>
+// `Opt<T>`
 is<Opt<string>>("hello");
 is<Opt<string>>(null);
-// @ts-expect-error `undefined` is not `Opt`
+// @ts-expect-error Argument of type `undefined` is not assignable to parameter of type `Opt<string>`.
 is<Opt<string>>(undefined);
 
-// Nullable<T>
+// `Nullable<T>`
 is<Nullable<string>>("hello");
 is<Nullable<string>>(null);
 is<Nullable<string>>(undefined);
+
+// `NonNullableKeys<T>`
+interface Hello { hello: Nullable<string> };
+is<NonNullableKeys<Hello>>({ hello: "hello" })
+// @ts-expect-error Type `null` is not assignable to type `string`.
+is<NonNullableKeys<Hello>>({ hello: null })
+// @ts-expect-error Type `undefined` is not assignable to type `string`.
+is<NonNullableKeys<Hello>>({ hello: undefined })

libs/ts-standard/src/filter.ts

@@ -4,7 +4,7 @@
  * @module
  */
 
-import { Nullable } from "@";
+import { NonNullableKeys, Nullable } from "@";
 
 /**
  * Check if a value is not `null` and not `undefined`.
@@ -23,3 +23,24 @@ import { Nullable } from "@";
 export function isNonNullable<T>(value: Nullable<T>): value is NonNullable<T> {
   return value != null;
 }
+
+/**
+ * Check if an object has `NonNullable` values for the given keys.
+ *
+ * @typeParam T - type of value to check
+ *
+ * @param keys - to check values of
+ * @returns - function to check a given value
+ *
+ * @example
+ * interface Hello { hello: Nullable<string>; };
+ * const isString = isNonNullableKeys<Hello>(["hello"])({ hello: "hello" }); // true
+ * const isNull = isNonNullableKeys<Hello>(["hello"])({ hello: null }); // false
+ * const isUndefined = isNonNullableKeys<Hello>(["hello"])({ hello: undefined }); // false
+ */
+export function isNonNullableKeys<T, K extends keyof T = keyof T>(
+  keys: K[]
+): (value: T) => value is NonNullableKeys<Pick<T, K>> & T {
+  return (value: T): value is NonNullableKeys<Pick<T, K>> & T =>
+    keys.every((key) => isNonNullable(value[key]));
+}

libs/ts-standard/src/index.ts

@@ -5,4 +5,4 @@
  */
 
 export { isNonNullable } from './filter';
-export type { Nullable, Opt } from './type';
+export type { NonNullableKeys, Nullable, Opt } from './type';

libs/ts-standard/src/type.ts

@@ -27,3 +27,16 @@ export type Opt<T> = T | null;
  * const nullableUndefined: Nullable<string> = undefined;
  */
 export type Nullable<T> = Opt<T> | undefined;
+
+/**
+ * Type that maps all properties in `T` to `NonNullable`
+ *
+ * @typeParam T - type to map
+ *
+ * @example
+ * interface Hello { hello: Nullable<string>; };
+ * type HelloNonNullableKeys = NonNullableKeys<Hello>; // { hello: string; }
+ */
+export type NonNullableKeys<T> = {
+  [K in keyof T]: NonNullable<T[K]>;
+};

libs/ts-standard/test/filter.test.ts

@@ -8,21 +8,37 @@ import { describe } from 'node:test';
 
 import { expect, test } from 'vitest'
 
-import { isNonNullable } from '@';
+import { isNonNullable, Nullable } from '@';
+
+import { isNonNullableKeys } from '../src/filter';
 
 void describe('isNonNullable', () => {
   test.each([
     ["hello", true],
     [null, false],
     [undefined, false],
-  ])('isNonNullable(%o) -> %o', (value, expected) => {
+  ])('%# isNonNullable(%o) -> %o', (value, expected) => {
     expect(isNonNullable(value)).toBe(expected);
   });
 
   test.each([
     [[], []],
     [["hello", null, "there", undefined], ["hello", "there"]],
-  ])('%o.filter(isNonNullable) -> %o', (value, expected) => {
+  ])('%# %o.filter(isNonNullable) -> %o', (value, expected) => {
     expect(value.filter(isNonNullable)).toStrictEqual(expected);
-  })
+  });
 })
+
+void describe('isNonNullableKeys', () => {
+  interface Hello { hello: Nullable<string> };
+  test.each([
+    [{ hello: "hello" }, ["hello"], true],
+    [{ hello: "hello" }, [], true],
+    [{ hello: null }, ["hello"], false],
+    [{ hello: null }, [], true],
+    [{ hello: undefined }, ["hello"], false],
+    [{ hello: undefined }, [], true],
+  ])('%# isNonNullableKeys(%o) -> %o', (value, keys, expected) => {
+    expect(isNonNullableKeys<Hello>(keys as (keyof Hello)[])(value)).toBe(expected);
+  });
+});