feat: add vendored neverthrow

Author: joshunrau

src/__tests__/exception.test.ts

@@ -1,8 +1,8 @@
-import { Err } from 'neverthrow';
 import type { Simplify } from 'type-fest';
 import { describe, expect, expectTypeOf, it, test } from 'vitest';
 
 import { BaseException, ExceptionBuilder, OutOfRangeException, ValueException } from '../exception.js';
+import { Err } from '../vendor/neverthrow.js';
 
 import type { ExceptionConstructor } from '../exception.js';
 

src/__tests__/http.test.ts

@@ -1,9 +1,10 @@
-import type { Err } from 'neverthrow';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import * as datetime from '../datetime.js';
 import { safeFetch, waitForServer } from '../http.js';
 
+import type { Err } from '../vendor/neverthrow.js';
+
 const fetch = vi.hoisted(() => vi.fn());
 const networkError = new Error('Network Error');
 

src/__tests__/result.test.ts

@@ -1,7 +1,7 @@
-import { Err, err, Ok, ok } from 'neverthrow';
 import { describe, expect, it } from 'vitest';
 
 import { asyncResultify } from '../result.js';
+import { Err, err, Ok, ok } from '../vendor/neverthrow.js';
 
 describe('asyncResultify', () => {
   it('should convert a successful Result to ResultAsync', async () => {

src/datetime.ts

@@ -1,7 +1,7 @@
-import { err, ok } from 'neverthrow';
-import type { Result } from 'neverthrow';
-
 import { OutOfRangeException } from './exception.js';
+import { err, ok } from './vendor/neverthrow.js';
+
+import type { Result } from './vendor/neverthrow.js';
 
 export type Duration = {
   days: number;

src/exception.ts

@@ -4,13 +4,13 @@
 
 import cleanStack from 'clean-stack';
 import extractStack from 'extract-stack';
-import { err, errAsync, Result, ResultAsync } from 'neverthrow';
 import stringifyObject from 'stringify-object';
 import type { IsNever, RequiredKeysOf } from 'type-fest';
 import type { z } from 'zod';
 
 import { objectify } from './object.js';
 import { indentLines } from './string.js';
+import { err, errAsync, Result, ResultAsync } from './vendor/neverthrow.js';
 
 import type { SingleKeyMap, ToAbstractConstructor } from './types.js';
 

src/http.ts

@@ -1,8 +1,7 @@
-import { ok, ResultAsync } from 'neverthrow';
-
 import { sleep } from './datetime.js';
 import { ExceptionBuilder, RuntimeException } from './exception.js';
 import { asyncResultify } from './result.js';
+import { ok, ResultAsync } from './vendor/neverthrow.js';
 
 import type { ExceptionLike } from './exception.js';
 

src/random.ts

@@ -1,7 +1,7 @@
-import { ok } from 'neverthrow';
-import type { Result } from 'neverthrow';
-
 import { ValueException } from './exception.js';
+import { ok } from './vendor/neverthrow.js';
+
+import type { Result } from './vendor/neverthrow.js';
 
 /** Returns a random integer between `min` (inclusive) and `max` (not inclusive) */
 export function randomInt(min: number, max: number): Result<number, typeof ValueException.Instance> {

src/range.ts

@@ -1,7 +1,7 @@
-import { ok } from 'neverthrow';
-import type { Result } from 'neverthrow';
-
 import { ValueException } from './exception.js';
+import { ok } from './vendor/neverthrow.js';
+
+import type { Result } from './vendor/neverthrow.js';
 
 /** Return an array of integers between 0 (inclusive) and `end` (not inclusive) */
 export function range(end: number): Result<readonly number[], typeof ValueException.Instance>;

src/result.ts

@@ -1,4 +1,4 @@
-import { Result, ResultAsync } from 'neverthrow';
+import { Result, ResultAsync } from './vendor/neverthrow.js';
 
 export function asyncResultify<T, E>(fn: () => Promise<Result<T, E>>): ResultAsync<T, E> {
   return new ResultAsync(fn());

src/vendor/neverthrow.ts

@@ -0,0 +1,40 @@
+/* eslint-disable @typescript-eslint/only-throw-error */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/consistent-type-definitions */
+
+import { Err, Ok, Result } from 'neverthrow';
+
+declare module 'neverthrow' {
+  interface Err<T, E> {
+    unwrap(): T;
+  }
+  interface Ok<T, E> {
+    unwrap(): T;
+  }
+}
+
+function unwrap<T, E>(this: Result<T, E>): any {
+  if (this.isErr()) {
+    throw this.error;
+  }
+  return this.value;
+}
+
+Err.prototype.unwrap = unwrap;
+Ok.prototype.unwrap = unwrap;
+
+export { Err, Ok };
+
+export {
+  err,
+  errAsync,
+  fromAsyncThrowable,
+  fromPromise,
+  fromSafePromise,
+  fromThrowable,
+  ok,
+  okAsync,
+  Result,
+  ResultAsync,
+  safeTry
+} from 'neverthrow';