@jakubmazanec/ts-utils 1.0.0-fdb1c25

package/src/utils/assert.ts

@@ -0,0 +1,44 @@
+/**
+ * A subclass of `Error` that indicates an assertion  failure.
+ */
+export class AssertionError extends Error {
+  /**
+   * @param message Message added to the default error message
+   */
+  constructor(message?: string) {
+    super(`Wrong assertion encountered${message ? `: "${message}"` : ''}!`);
+
+    this.name = 'AssertionError';
+  }
+}
+
+/**
+ * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if
+ * `condition` is falsy.
+ * You can use it to narrow types:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   kind: 'Foo';
+ * }
+ *
+ * interface Bar {
+ *   kind: 'Bar';
+ * }
+ *
+ * declare const foobar: Foo | Bar;
+ *
+ * assert(is<Foo>(foobar, foobar.kind === 'Foo'));
+ *
+ * // `typeof foobar` is now `Foo`
+ * ```
+ *
+ * @param condition Condition we're asserting isn't falsy
+ * @param errorMessage Message for the `AssertionError`
+ */
+export function assert(condition: unknown, errorMessage?: string): asserts condition {
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we don't mind here
+  if (!condition) {
+    throw new AssertionError(errorMessage);
+  }
+}

package/src/utils/is.ts

@@ -0,0 +1,30 @@
+/**
+ * A generic type guard. If `isMatched` is `true`, TypeScript assumes `value` is of type `T`.
+ * You can use it to narrow types:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   value: string;
+ * }
+ *
+ * interface Bar {
+ *   value: number;
+ * }
+ *
+ * declare let foobar: Foo | Bar;
+ *
+ * if (is<Foo>(foobar, typeof foobar.value === 'string')) {
+ *   // `typeof foobar` is now `Foo`
+ * } else {
+ *   // `typeof foobar` is now `Bar`
+ * }
+ * ```
+ *
+ * @typeParam T Potential type of `value`
+ * @param value Value being checked
+ * @param isMatched Specifies if `value` is of type `T`
+ * @return Value of `isMatched`
+ */
+export function is<T>(value: unknown, isMatched: boolean): value is T {
+  return isMatched;
+}

package/src/utils/isNonNullable.ts

@@ -0,0 +1,20 @@
+/**
+ * A type guard that checks whether variable is not `null` or `undefined`:
+ *
+ * ```TypeScript
+ * declare let foobar: string | null;
+ *
+ * if (isNonNullable(foobar)) {
+ *   // `typeof foobar` is now `string`
+ * } else {
+ *   // `typeof foobar` is now `null`
+ * }
+ * ```
+ *
+ * @typeParam T Type of `value`
+ * @param value Value being checked
+ * @return `true` if `value` is non-nullable
+ */
+export function isNonNullable<T>(value: T): value is NonNullable<T> {
+  return value !== undefined && value !== null;
+}

package/src/utils.ts

@@ -0,0 +1,3 @@
+export * from './utils/assert.js';
+export * from './utils/is.js';
+export * from './utils/isNonNullable.js';