nalloc 0.2.2 → 0.5.0

package/src/__tests__/http.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { fromResponse, fromFetch } from '../http.js';
+import { isOk, isErr } from '../types.js';
+
+describe('http', () => {
+  describe('fromResponse', () => {
+    it('returns Ok carrying the response for a 2xx status', () => {
+      const response = new Response('ok', { status: 200 });
+      const result = fromResponse(response);
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(response);
+    });
+
+    it('returns Err carrying the response for a non-2xx status', () => {
+      const response = new Response('nope', { status: 404 });
+      const result = fromResponse(response);
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: Response }).error).toBe(response);
+    });
+  });
+
+  describe('fromFetch', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    it('returns Ok carrying the response for a 2xx status', async () => {
+      const response = new Response('ok', { status: 200 });
+      const fetchMock = vi.fn().mockResolvedValue(response);
+      vi.stubGlobal('fetch', fetchMock);
+      const init = { method: 'POST' };
+      const result = await fromFetch('https://example.test', init);
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(response);
+      expect(fetchMock).toHaveBeenCalledWith('https://example.test', init);
+    });
+
+    it('returns Err carrying the response for a non-2xx status', async () => {
+      const response = new Response('nope', { status: 500 });
+      vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response));
+      const result = await fromFetch('https://example.test');
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: Response }).error).toBe(response);
+    });
+
+    it('returns Err carrying the thrown value on transport failure', async () => {
+      const failure = new TypeError('fetch failed');
+      vi.stubGlobal('fetch', vi.fn().mockRejectedValue(failure));
+      const result = await fromFetch('https://example.test');
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: unknown }).error).toBe(failure);
+    });
+
+    it('returns Err with an AbortError DOMException for a pre-aborted signal', async () => {
+      const controller = new AbortController();
+      controller.abort();
+      const result = await fromFetch('http://127.0.0.1:1', { signal: controller.signal });
+      expect(isErr(result)).toBe(true);
+      const error = (result as { error: unknown }).error;
+      expect(error).toBeInstanceOf(DOMException);
+      expect((error as DOMException).name).toBe('AbortError');
+    });
+  });
+});

package/src/__tests__/iter.ts

@@ -96,6 +96,24 @@ describe('Iter', () => {
       expect(returned).toBe(true);
     });
 
+    it('return() after exhaustion is a no-op', () => {
+      let returnCalls = 0;
+      const iter: Iterable<number> = {
+        [Symbol.iterator]: () => {
+          let i = 0;
+          return {
+            next() { return i++ < 1 ? { value: i, done: false } : { value: undefined as unknown as number, done: true }; },
+            return() { returnCalls++; return { value: undefined, done: true }; },
+          };
+        },
+      };
+      const gen = safeIter(iter);
+      expect([...gen]).toHaveLength(1);
+      const final = gen.return!(undefined as never);
+      expect(final.done).toBe(true);
+      expect(returnCalls).toBe(0);
+    });
+
     it('yields values then stops on throw', () => {
       function* twoThenThrow() {
         yield 1;

package/src/__tests__/nonempty.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { isNonEmpty, assertNonEmpty, fromArray } from '../nonempty.js';
+import { isSome, isNone } from '../types.js';
+
+describe('NonEmpty', () => {
+  describe('isNonEmpty', () => {
+    it('returns false for an empty array', () => {
+      expect(isNonEmpty([])).toBe(false);
+    });
+
+    it('returns true for a single-element array', () => {
+      expect(isNonEmpty([1])).toBe(true);
+    });
+
+    it('returns true for a multi-element array', () => {
+      expect(isNonEmpty([1, 2, 3])).toBe(true);
+    });
+  });
+
+  describe('assertNonEmpty', () => {
+    it('throws on an empty array', () => {
+      expect(() => assertNonEmpty([])).toThrow('Expected array to be non-empty');
+    });
+
+    it('throws with a custom message', () => {
+      expect(() => assertNonEmpty([], 'nope')).toThrow('nope');
+    });
+
+    it('does not throw on a non-empty array', () => {
+      expect(() => assertNonEmpty([1])).not.toThrow();
+    });
+  });
+
+  describe('fromArray', () => {
+    it('returns None for an empty array', () => {
+      expect(isNone(fromArray([]))).toBe(true);
+    });
+
+    it('returns Some wrapping the same array value for a non-empty array', () => {
+      const input = [1, 2];
+      const result = fromArray(input);
+      expect(isSome(result)).toBe(true);
+      expect(result).toBe(input);
+    });
+  });
+});

package/src/__tests__/nonempty.types.ts

@@ -0,0 +1,38 @@
+import { assert, type Equals } from 'tsafe';
+import {
+  isNonEmpty,
+  assertNonEmpty,
+  fromArray,
+  type NonEmptyArray,
+  type ReadonlyNonEmptyArray,
+} from '../nonempty.js';
+import type { Option } from '../types.js';
+
+const readonlyValues: readonly number[] = [1, 2, 3];
+const mutableValues: number[] = [1, 2, 3];
+
+if (isNonEmpty(readonlyValues)) {
+  assert<Equals<typeof readonlyValues, ReadonlyNonEmptyArray<number>>>;
+  const _head: number = readonlyValues[0];
+}
+
+if (isNonEmpty(mutableValues)) {
+  const _head: number = mutableValues[0];
+}
+
+const asserted: readonly number[] = [1];
+assertNonEmpty(asserted);
+assert<Equals<typeof asserted, ReadonlyNonEmptyArray<number>>>;
+const _assertedHead: number = asserted[0];
+
+const maybeNonEmpty = fromArray<number>([1, 2]);
+assert<Equals<typeof maybeNonEmpty, Option<ReadonlyNonEmptyArray<number>>>>;
+
+const fromEmpty = fromArray([] as const);
+assert<Equals<typeof fromEmpty, Option<ReadonlyNonEmptyArray<never>>>>;
+
+type _MutableShape = Equals<NonEmptyArray<number>, [number, ...number[]]>;
+assert<_MutableShape>;
+
+type _ReadonlyShape = Equals<ReadonlyNonEmptyArray<number>, readonly [number, ...number[]]>;
+assert<_ReadonlyShape>;

package/src/__tests__/option.ts

@@ -426,6 +426,10 @@ describe('Option', () => {
     it('returns false for None', () => {
       expect(contains(none, 42)).toBe(false);
     });
+
+    it('treats NaN as equal to NaN', () => {
+      expect(contains(of(NaN), NaN)).toBe(true);
+    });
   });
 
   describe('isSomeAnd', () => {